sentry-vir 2.0.0 → 3.0.0

package/LICENSE-MIT

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 electrovir
+Copyright (c) 2024 electrovir
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -21,12 +21,9 @@ Full api reference: https://electrovir.github.io/sentry-vir
 <!-- example-link: src/readme-examples/init-sentry.example.ts -->
 
 ```TypeScript
-/**
- * If initializing sentry for node, instead import from 'sentry-vir/dist/esm/node' (for ESM) or
- * 'sentry-vir/dist/cjs/node' (for CommonJS).
- */
+/** If initializing sentry for node, instead import from 'sentry-vir/dist/node'. */
 import {SentryReleaseEnvEnum} from 'sentry-vir';
-import {initSentry} from 'sentry-vir/dist/esm/browser';
+import {initSentry} from 'sentry-vir/dist/browser';
 
 initSentry({
     dsn: 'Sentry project id provided by Sentry',
@@ -48,7 +45,7 @@ initSentry({
 
 ```TypeScript
 import {SentryReleaseEnvEnum, handleError, sendLog, throwWithExtraContext} from 'sentry-vir';
-import {initSentry} from 'sentry-vir/dist/esm/browser';
+import {initSentry} from 'sentry-vir/dist/browser';
 
 sendLog.info('starting file');
 /** Extra log context can be added as the second argument to a sendLog method. */

package/dist/{cjs/auto.d.ts → auto.d.ts}

@@ -1,5 +1,5 @@
-import { SentryDep, SentryExecutionEnvEnum } from './env/execution-env';
-import { InitSentryInput } from './init-sentry/base-sentry-init';
+import { type SentryDep, SentryExecutionEnvEnum } from './env/execution-env.js';
+import { type InitSentryInput } from './init-sentry/base-sentry-init.js';
 /** A function which imports a Sentry dep. */
 export type SentryDepImporter = () => Promise<SentryDep>;
 /** The sentry dep import for each execution env. */

package/dist/{esm/auto.js → auto.js}

@@ -1,5 +1,5 @@
-import { SentryExecutionEnvEnum } from './env/execution-env';
-import { baseInitSentry } from './init-sentry/base-sentry-init';
+import { SentryExecutionEnvEnum } from './env/execution-env.js';
+import { baseInitSentry } from './init-sentry/base-sentry-init.js';
 /** The sentry dep import for each execution env. */
 export const sentryDepByEnv = {
     /** Sentry client for the browser. */

package/dist/{esm/browser.d.ts → browser.d.ts}

@@ -1,5 +1,5 @@
-import type { SentryBrowserDep } from './env/execution-env';
-import { InitSentryInput } from './init-sentry/base-sentry-init';
+import { type SentryBrowserDep } from './env/execution-env.js';
+import { type InitSentryInput } from './init-sentry/base-sentry-init.js';
 export type Sentry = SentryBrowserDep;
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client

package/dist/{esm/browser.js → browser.js}

@@ -1,5 +1,5 @@
-import { SentryExecutionEnvEnum } from './env/execution-env';
-import { baseInitSentry } from './init-sentry/base-sentry-init';
+import { SentryExecutionEnvEnum } from './env/execution-env.js';
+import { baseInitSentry } from './init-sentry/base-sentry-init.js';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/{esm/event-context → event-context}/event-context.d.ts

@@ -1,5 +1,5 @@
-import type { ScopeContext } from '@sentry/types';
-import { EventSeverityEnum } from './event-severity';
+import { type ScopeContext } from '@sentry/core';
+import { type EventSeverityEnum } from './event-severity.js';
 /**
  * Used for all extra context types. While keys must be strings, values can be whatever but must be
  * JSON compatible.

package/dist/event-context/event-severity.d.ts

@@ -0,0 +1,15 @@
+import { type Event as SentryEvent } from '@sentry/browser';
+/** Mapped from Sentry's values into an enum for convenience of use. */
+export declare enum EventSeverityEnum {
+    Warning = "warning",
+    Info = "info",
+    Debug = "debug",
+    Fatal = "fatal",
+    Error = "error"
+}
+/** Event severities that are not error-level. */
+export type InfoEventSeverity = EventSeverityEnum.Debug | EventSeverityEnum.Info | EventSeverityEnum.Warning;
+/** Maps severities to the console methods used to log them. */
+export declare const consoleLogMethodPerSeverity: Readonly<Record<EventSeverityEnum, (typeof console)['log']>>;
+/** Extracts the severity level from a sentry event while defaulting to an info level severity. */
+export declare function extractEventSeverity(event: SentryEvent): EventSeverityEnum;

package/dist/{esm/event-context → event-context}/event-severity.js

@@ -1,4 +1,4 @@
-import { isEnumValue } from '@augment-vir/common';
+import { check } from '@augment-vir/assert';
 /** Mapped from Sentry's values into an enum for convenience of use. */
 export var EventSeverityEnum;
 (function (EventSeverityEnum) {
@@ -15,6 +15,7 @@ export const consoleLogMethodPerSeverity = {
     /** Maps to `console.info`. */
     [EventSeverityEnum.Info]: console.info,
     /** Maps to `console.debug`. */
+    // eslint-disable-next-line no-console
     [EventSeverityEnum.Debug]: console.debug,
     /** Maps to `console.error`. */
     [EventSeverityEnum.Fatal]: console.error,
@@ -23,7 +24,7 @@ export const consoleLogMethodPerSeverity = {
 };
 /** Extracts the severity level from a sentry event while defaulting to an info level severity. */
 export function extractEventSeverity(event) {
-    if (!isEnumValue(event.level, EventSeverityEnum)) {
+    if (!check.isEnumValue(event.level, EventSeverityEnum)) {
         return EventSeverityEnum.Info;
     }
     return event.level;

package/dist/{cjs/event-context → event-context}/extra-context.error.d.ts

@@ -1,17 +1,14 @@
-import { EventExtraContext } from './event-context';
-import { extraEventContextSymbol, HasExtraContext } from './extra-event-context';
+import { type EventExtraContext } from './event-context.js';
+import { extraEventContextSymbol, type HasExtraContext } from './extra-event-context.js';
 /**
  * Constructs an error with extra event context attached to it in the same way that
  * throwWithExtraContext attaches data.
  *
  * The following examples are equivalent:
  *
- * @example
- *     throw new ExtraContextError('my error', {stuff: 'hi'});
+ * @example Throw new ExtraContextError('my error', {stuff: 'hi'});
  *
- * @example
- *     const myError = new Error('my error');
- *     throwWithExtraContext(myError, {stuff: 'hi'});
+ * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {stuff: 'hi'});
  */
 export declare class ExtraContextError extends Error implements HasExtraContext {
     readonly [extraEventContextSymbol]: EventExtraContext;

package/dist/{esm/event-context → event-context}/extra-context.error.js

@@ -1,32 +1,22 @@
-var _a;
 import { ensureError } from '@augment-vir/common';
-import { extraEventContextSymbol } from './extra-event-context';
+import { extraEventContextSymbol } from './extra-event-context.js';
 /**
  * Constructs an error with extra event context attached to it in the same way that
  * throwWithExtraContext attaches data.
  *
  * The following examples are equivalent:
  *
- * @example
- *     throw new ExtraContextError('my error', {stuff: 'hi'});
+ * @example Throw new ExtraContextError('my error', {stuff: 'hi'});
  *
- * @example
- *     const myError = new Error('my error');
- *     throwWithExtraContext(myError, {stuff: 'hi'});
+ * @example Const myError = new Error('my error'); throwWithExtraContext(myError, {stuff: 'hi'});
  */
 export class ExtraContextError extends Error {
+    [extraEventContextSymbol];
     constructor(message, extraData) {
         super(message);
-        Object.defineProperty(this, _a, {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this[extraEventContextSymbol] = extraData;
     }
 }
-_a = extraEventContextSymbol;
 /**
  * Adds extra context to an error without modifying the error's message or stack trace (or any of
  * its other properties), then throws the error so it can propagate as usual.

package/dist/{esm/event-context → event-context}/extra-event-context.d.ts

@@ -1,5 +1,5 @@
-import { Event, EventHint } from '@sentry/types';
-import { EventExtraContext } from './event-context';
+import { type Event, type EventHint } from '@sentry/core';
+import { type EventExtraContext } from './event-context.js';
 /**
  * Symbol used to attach extra event context to events. This is particularly useful for errors so
  * they can be thrown while attaching this extra context to them.

package/dist/{esm/event-context → event-context}/extra-event-context.js

@@ -1,4 +1,4 @@
-import { typedHasProperty } from '@augment-vir/common';
+import { check } from '@augment-vir/assert';
 /**
  * Symbol used to attach extra event context to events. This is particularly useful for errors so
  * they can be thrown while attaching this extra context to them.
@@ -6,7 +6,7 @@ import { typedHasProperty } from '@augment-vir/common';
 export const extraEventContextSymbol = Symbol('extra-event-context');
 /** Type guard for whether any given input has extra event context. */
 export function hasExtraEventContext(input) {
-    return typedHasProperty(input, extraEventContextSymbol);
+    return check.hasKey(input, extraEventContextSymbol);
 }
 /**
  * Checks if extra event context has been injected into the input via extraEventContextSymbol and,
@@ -30,7 +30,7 @@ export function extractExtraEventContext(event) {
         ? extractExtraContentFromSymbol(event.originalException)
         : undefined;
     const fromCapture = 'captureContext' in event && 'extra' in event.captureContext
-        ? event.captureContext?.extra
+        ? event.captureContext.extra
         : undefined;
     const combined = {
         ...fromRootSymbol,

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './env/execution-env.js';
+export * from './event-context/event-context.js';
+export * from './event-context/event-severity.js';
+export * from './event-context/extra-context.error.js';
+export * from './event-context/extra-event-context.js';
+export * from './init-sentry/base-sentry-init.js';
+export * from './init-sentry/sentry-config.js';
+export * from './logging/attach-tags.js';
+export * from './logging/handle-error.js';
+export * from './logging/send-log.js';
+export * from './logging/sentry-client-for-logging.js';
+export * from './processing/event-processor.js';
+export * from './processing/handle-sentry-send.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './env/execution-env.js';
+export * from './event-context/event-context.js';
+export * from './event-context/event-severity.js';
+export * from './event-context/extra-context.error.js';
+export * from './event-context/extra-event-context.js';
+export * from './init-sentry/base-sentry-init.js';
+export * from './init-sentry/sentry-config.js';
+export * from './logging/attach-tags.js';
+export * from './logging/handle-error.js';
+export * from './logging/send-log.js';
+export * from './logging/sentry-client-for-logging.js';
+export * from './processing/event-processor.js';
+export * from './processing/handle-sentry-send.js';

package/dist/{cjs/init-sentry → init-sentry}/base-sentry-init.d.ts

@@ -1,7 +1,7 @@
-import type { Options } from '@sentry/types';
-import { SentryDep, SentryExecutionEnvEnum } from '../env/execution-env';
-import { EventExtraContextCreator } from '../event-context/event-context';
-import { UserOverrides } from './sentry-config';
+import { type Options } from '@sentry/core';
+import { type SentryDep, type SentryExecutionEnvEnum } from '../env/execution-env.js';
+import { type EventExtraContextCreator } from '../event-context/event-context.js';
+import { type UserOverrides } from './sentry-config.js';
 /** Configuration for initializing Sentry. */
 export type InitSentryInput = {
     /** The release environment, rather than the execution environment (browser vs node). */

package/dist/{esm/init-sentry → init-sentry}/base-sentry-init.js

@@ -1,6 +1,6 @@
-import { setSentryClientForLogging } from '../logging/sentry-client-for-logging';
-import { processSentryEvent } from '../processing/event-processor';
-import { createSentryConfig } from './sentry-config';
+import { setSentryClientForLogging } from '../logging/sentry-client-for-logging.js';
+import { processSentryEvent } from '../processing/event-processor.js';
+import { createSentryConfig } from './sentry-config.js';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.
@@ -15,6 +15,6 @@ export async function baseInitSentry({ dsn, releaseEnv, releaseName, sentryConfi
     }, sentryConfigOverrides, isDev);
     sentryDep.init(finalSentryConfig);
     sentryDep.addEventProcessor((event, hint) => processSentryEvent(event, hint, createUniversalContext));
-    setSentryClientForLogging(sentryDep);
+    void setSentryClientForLogging(sentryDep);
     return sentryDep;
 }

package/dist/{cjs/init-sentry → init-sentry}/sentry-config.d.ts

@@ -1,7 +1,7 @@
 import { type BrowserOptions } from '@sentry/browser';
-import type { NodeOptions } from '@sentry/node';
-import { type Options } from '@sentry/types';
-import { SentryDepByEnv, SentryExecutionEnvEnum } from '../env/execution-env';
+import { type Options } from '@sentry/core';
+import { type NodeOptions } from '@sentry/node';
+import { type SentryDepByEnv, SentryExecutionEnvEnum } from '../env/execution-env.js';
 /** Optional UserOverrides of Sentry config values. */
 export type UserOverrides = Omit<Partial<Options>, keyof RequiredSentryOptions> | undefined;
 /** Sentry config options that are required. */

package/dist/{esm/init-sentry → init-sentry}/sentry-config.js

@@ -1,8 +1,8 @@
 import { mergeDeep } from '@augment-vir/common';
-import { SentryExecutionEnvEnum, } from '../env/execution-env';
-import { createSentryHandler } from '../processing/handle-sentry-send';
+import { SentryExecutionEnvEnum, } from '../env/execution-env.js';
+import { createSentryHandler } from '../processing/handle-sentry-send.js';
 /** Creates the sentry config used internally by sentry-vir. */
-export async function createSentryConfig(executionEnv, sentryDep, requiredSentryOptions, userOverrides, isDev) {
+export function createSentryConfig(executionEnv, sentryDep, requiredSentryOptions, userOverrides, isDev) {
     const sharedSentryConfig = {
         beforeSend: createSentryHandler(isDev),
         beforeSendTransaction: createSentryHandler(isDev),
@@ -26,7 +26,7 @@ const sentryConfigByEnv = {
             integrations: [
                 BrowserSentry.httpContextIntegration(),
                 BrowserSentry.dedupeIntegration(),
-                BrowserSentry.inboundFiltersIntegration(),
+                BrowserSentry.eventFiltersIntegration(),
                 BrowserSentry.functionToStringIntegration(),
                 BrowserSentry.globalHandlersIntegration(),
             ],

package/dist/{cjs/logging → logging}/attach-tags.d.ts

@@ -1,4 +1,4 @@
-import type { setTags } from '@sentry/core';
+import { type setTags } from '@sentry/core';
 /** A list of tag names as keys and their values. Set a tag to undefined to clear it. */
 export type SentryTags = Parameters<typeof setTags>[0];
 /** Set tags for all future Sentry event handling (errors and logs). */

package/dist/{esm/logging → logging}/attach-tags.js

@@ -1,5 +1,5 @@
-import { addPrematureEvent } from './premature-events';
-import { sentryClientForLogging } from './sentry-client-for-logging';
+import { addPrematureEvent } from './premature-events.js';
+import { sentryClientForLogging } from './sentry-client-for-logging.js';
 /** Set tags for all future Sentry event handling (errors and logs). */
 export function attachSentryTags(tags) {
     try {

package/dist/{cjs/logging → logging}/handle-error.d.ts

@@ -1,3 +1,3 @@
-import { EventExtraContext } from '../event-context/event-context';
+import { type EventExtraContext } from '../event-context/event-context.js';
 /** Record an error to Sentry without throwing it. */
 export declare function handleError(error: unknown, extraContext?: EventExtraContext): string | undefined;

package/dist/{esm/logging → logging}/handle-error.js

@@ -1,9 +1,9 @@
 import { extractErrorMessage } from '@augment-vir/common';
-import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
-import { EventSeverityEnum } from '../event-context/event-severity';
-import { LoggingState, logToConsoleWithoutSentry } from '../processing/log-to-console';
-import { addPrematureEvent } from './premature-events';
-import { sentryClientForLogging } from './sentry-client-for-logging';
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context.js';
+import { EventSeverityEnum } from '../event-context/event-severity.js';
+import { LoggingState, logToConsoleWithoutSentry } from '../processing/log-to-console.js';
+import { addPrematureEvent } from './premature-events.js';
+import { sentryClientForLogging } from './sentry-client-for-logging.js';
 /** Record an error to Sentry without throwing it. */
 export function handleError(error, extraContext) {
     return internalHandleError(error, extraContext, {

package/dist/{cjs/logging → logging}/premature-events.d.ts

@@ -1,3 +1,3 @@
-import { AnyFunction } from '@augment-vir/common';
+import { type AnyFunction } from '@augment-vir/common';
 export declare function sendPrematureEvents(): void;
 export declare function addPrematureEvent<EntryPointFunction extends AnyFunction = AnyFunction>(callback: EntryPointFunction, inputs: Parameters<EntryPointFunction>): void;

package/dist/{esm/logging → logging}/send-log.d.ts

@@ -1,5 +1,5 @@
-import { Event as SentryEvent } from '@sentry/types';
-import { ContextOptions, EventDetails, EventExtraContext } from '../event-context/event-context';
+import { type Event as SentryEvent } from '@sentry/core';
+import { type ContextOptions, type EventDetails, type EventExtraContext } from '../event-context/event-context.js';
 /** Send non-error events to Sentry. */
 export declare const sendLog: {
     /** Sends an even to Sentry with debug severity. */

package/dist/{esm/logging → logging}/send-log.js

@@ -1,10 +1,10 @@
-import { isRunTimeType } from 'run-time-assertions';
-import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
-import { EventSeverityEnum } from '../event-context/event-severity';
-import { extractOriginalMessage } from '../processing/event-processor';
-import { LoggingState, logToConsoleWithoutSentry } from '../processing/log-to-console';
-import { addPrematureEvent } from './premature-events';
-import { sentryClientForLogging } from './sentry-client-for-logging';
+import { check } from '@augment-vir/assert';
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context.js';
+import { EventSeverityEnum } from '../event-context/event-severity.js';
+import { extractOriginalMessage } from '../processing/event-processor.js';
+import { LoggingState, logToConsoleWithoutSentry } from '../processing/log-to-console.js';
+import { addPrematureEvent } from './premature-events.js';
+import { sentryClientForLogging } from './sentry-client-for-logging.js';
 /** Send non-error events to Sentry. */
 export const sendLog = {
     /** Sends an even to Sentry with debug severity. */
@@ -28,10 +28,10 @@ function sendLogToSentry(logInfo, eventDetails, options) {
     try {
         if (!sentryClientForLogging) {
             logToConsoleWithoutSentry(eventDetails.severity, LoggingState.NoSentryYet, {
-                message: isRunTimeType(logInfo, 'string')
+                message: check.isString(logInfo)
                     ? logInfo
                     : extractOriginalMessage(logInfo, undefined),
-                event: isRunTimeType(logInfo, 'string') ? undefined : logInfo,
+                event: check.isString(logInfo) ? undefined : logInfo,
                 extra: eventDetails.extraContext,
                 hint: undefined,
                 originalException: undefined,
@@ -44,7 +44,7 @@ function sendLogToSentry(logInfo, eventDetails, options) {
             return undefined;
         }
         const scopeContext = convertEventDetailsToSentryContext(eventDetails, options);
-        const eventId = isRunTimeType(logInfo, 'string')
+        const eventId = check.isString(logInfo)
             ? sentryClientForLogging.captureMessage(logInfo, scopeContext)
             : sentryClientForLogging.captureEvent({
                 ...logInfo,

package/dist/{esm/logging → logging}/sentry-client-for-logging.d.ts

@@ -1,5 +1,5 @@
-import { MaybePromise } from '@augment-vir/common';
-import { SentryDep } from '../env/execution-env';
+import { type MaybePromise } from '@augment-vir/common';
+import { type SentryDep } from '../env/execution-env.js';
 /** The bare minimum Sentry client needed for logging events. */
 export type SentryClientForLogging = Pick<SentryDep, 'captureMessage' | 'captureException' | 'captureEvent' | 'setTags'>;
 /** Internal sentry client used for logging. */

package/dist/{esm/logging → logging}/sentry-client-for-logging.js

@@ -1,4 +1,4 @@
-import { sendPrematureEvents } from './premature-events';
+import { sendPrematureEvents } from './premature-events.js';
 /** Internal sentry client used for logging. */
 export let sentryClientForLogging;
 /**

package/dist/{cjs/node.d.ts → node.d.ts}

@@ -1,5 +1,5 @@
-import type { SentryNodeDep } from './env/execution-env';
-import { InitSentryInput } from './init-sentry/base-sentry-init';
+import { type SentryNodeDep } from './env/execution-env.js';
+import { type InitSentryInput } from './init-sentry/base-sentry-init.js';
 export type Sentry = SentryNodeDep;
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client

package/dist/{esm/node.js → node.js}

@@ -1,5 +1,5 @@
-import { SentryExecutionEnvEnum } from './env/execution-env';
-import { baseInitSentry } from './init-sentry/base-sentry-init';
+import { SentryExecutionEnvEnum } from './env/execution-env.js';
+import { baseInitSentry } from './init-sentry/base-sentry-init.js';
 /**
  * Base Sentry init. Requires the Sentry module to already have been imported. Setup a sentry client
  * with all the default sentry-vir integrations and configs.

package/dist/{cjs/processing → processing}/event-processor.d.ts

@@ -1,5 +1,5 @@
-import { ErrorEvent, EventHint, Event as SentryEvent, TransactionEvent } from '@sentry/types';
-import { EventExtraContextCreator } from '../event-context/event-context';
+import { type ErrorEvent, type EventHint, type Event as SentryEvent, type TransactionEvent } from '@sentry/core';
+import { type EventExtraContextCreator } from '../event-context/event-context.js';
 /** Attach extra event data for a sentry event. */
 export declare function processSentryEvent(
 /** Event from Sentry. */

package/dist/{esm/processing → processing}/event-processor.js

@@ -1,7 +1,7 @@
 import { extractErrorMessage } from '@augment-vir/common';
-import { convertEventDetailsToSentryContext, } from '../event-context/event-context';
-import { extractEventSeverity } from '../event-context/event-severity';
-import { extractExtraEventContext } from '../event-context/extra-event-context';
+import { convertEventDetailsToSentryContext, } from '../event-context/event-context.js';
+import { extractEventSeverity } from '../event-context/event-severity.js';
+import { extractExtraEventContext } from '../event-context/extra-event-context.js';
 /** Attach extra event data for a sentry event. */
 export function processSentryEvent(
 /** Event from Sentry. */

package/dist/{cjs/processing → processing}/handle-sentry-send.d.ts

@@ -1,5 +1,5 @@
-import type { EventHint } from '@sentry/browser';
-import type { ErrorEvent, TransactionEvent } from '@sentry/types';
+import { type EventHint } from '@sentry/browser';
+import { type ErrorEvent, type TransactionEvent } from '@sentry/core';
 /** Creates a handler for Sentry events based on the given env. */
 export declare function createSentryHandler<T extends TransactionEvent | ErrorEvent>(
 /** If in dev, events won't be sent to Sentry. They will only be logged in the console. */

package/dist/{esm/processing → processing}/handle-sentry-send.js

@@ -1,4 +1,4 @@
-import { LoggingState, logToConsoleFromSentry } from './log-to-console';
+import { LoggingState, logToConsoleFromSentry } from './log-to-console.js';
 /** Creates a handler for Sentry events based on the given env. */
 export function createSentryHandler(
 /** If in dev, events won't be sent to Sentry. They will only be logged in the console. */

package/dist/{esm/processing → processing}/log-to-console.d.ts

@@ -1,6 +1,6 @@
-import { EventHint } from '@sentry/browser';
-import { Event, Extras } from '@sentry/types';
-import { EventSeverityEnum } from '../event-context/event-severity';
+import { type EventHint } from '@sentry/browser';
+import { type Event, type Extras } from '@sentry/core';
+import { type EventSeverityEnum } from '../event-context/event-severity.js';
 export declare enum LoggingState {
     Dev = "dev",
     Prod = "prod",

package/dist/{esm/processing → processing}/log-to-console.js

@@ -1,6 +1,6 @@
-import { isTruthy } from '@augment-vir/common';
-import { consoleLogMethodPerSeverity, extractEventSeverity, } from '../event-context/event-severity';
-import { extractOriginalMessage } from './event-processor';
+import { check } from '@augment-vir/assert';
+import { consoleLogMethodPerSeverity, extractEventSeverity, } from '../event-context/event-severity.js';
+import { extractOriginalMessage } from './event-processor.js';
 export var LoggingState;
 (function (LoggingState) {
     LoggingState["Dev"] = "dev";
@@ -31,12 +31,13 @@ export function logToConsoleWithoutSentry(severity, loggingState, logData) {
         logData.extra,
         Object.keys(eventLogArg).length ? eventLogArg : undefined,
         logData.originalException,
-    ].filter(isTruthy);
+    ].filter(check.isTruthy);
     if (loggingState === LoggingState.Dev) {
         consoleMethod('Would have sent to Sentry:', ...logArgs);
     }
     else if (loggingState === LoggingState.Prod) {
         consoleMethod('Sending to Sentry:', ...logArgs);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     }
     else if (loggingState === LoggingState.NoSentryYet) {
         consoleMethod('Logging before Sentry init:', ...logArgs);