@spotlightjs/overlay 0.0.16

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2023 Sentry
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/App.d.ts

@@ -0,0 +1,12 @@
+import { type Anchor } from './components/Trigger';
+import type { Integration } from './integrations/integration';
+type AppProps = {
+    fullScreen?: boolean;
+    showTriggerButton?: boolean;
+    defaultEventId?: string;
+    integrations?: Integration[];
+    sidecar: string;
+    anchor?: Anchor;
+};
+export default function App({ fullScreen, showTriggerButton, defaultEventId, integrations, sidecar, anchor, }: AppProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Debugger.d.ts

@@ -0,0 +1,9 @@
+import { Integration, IntegrationData } from '../integrations/integration';
+export default function Debugger({ integrations, isOpen, setOpen, integrationData, isOnline, }: {
+    integrations: Integration[];
+    isOpen: boolean;
+    setOpen: (value: boolean) => void;
+    defaultEventId?: string;
+    integrationData: IntegrationData<unknown>;
+    isOnline: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Overview.d.ts

@@ -0,0 +1,5 @@
+import { Integration, IntegrationData } from '../integrations/integration';
+export default function Overview({ integrations, integrationData, }: {
+    integrations: Integration[];
+    integrationData: IntegrationData<unknown>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Tabs.d.ts

@@ -0,0 +1,14 @@
+import { IntegrationTab } from '../integrations/integration';
+export type Props = {
+    /**
+     * Array of tabs to display.
+     */
+    tabs: IntegrationTab<unknown>[];
+    /**
+     * Whether the tabs are nested inside another tab.
+     * If `nested` is `true`, links will be set relative to the parent
+     * tab route instead of absolute to the root.
+     */
+    nested?: boolean;
+};
+export default function Tabs({ tabs, nested }: Props): import("react/jsx-runtime").JSX.Element;

package/dist/components/Trigger.d.ts

@@ -0,0 +1,9 @@
+import { TriggerButtonCount } from '../types';
+export declare const DEFAULT_ANCHOR = "bottomRight";
+export type Anchor = 'bottomRight' | 'bottomLeft' | 'centerRight' | 'centerLeft' | 'topLeft' | 'topRight';
+export default function Trigger({ isOpen, setOpen, count, anchor, }: {
+    isOpen: boolean;
+    setOpen: (value: boolean) => void;
+    count: TriggerButtonCount;
+    anchor?: Anchor;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { type Anchor } from './components/Trigger.tsx';
+import type { Integration } from './integrations/integration.ts';
+export { default as console } from './integrations/console/index.ts';
+export { default as sentry } from './integrations/sentry/index.ts';
+export { default as viteInspect } from './integrations/vite-inspect/index.ts';
+/**
+ * Open the Spotlight debugger Window
+ */
+export declare function openSpotlight(): Promise<void>;
+/**
+ * Close the Spotlight debugger Window
+ */
+export declare function closeSpotlight(): Promise<void>;
+/**
+ * Invokes the passed in callback when the Spotlight debugger Window is closed
+ */
+export declare function onClose(cb: () => void): Promise<void>;
+export declare function init({ fullScreen, showTriggerButton, integrations, defaultEventId, injectImmediately, sidecar, anchor, debug, }?: {
+    integrations?: Integration[];
+    fullScreen?: boolean;
+    defaultEventId?: string;
+    sidecarUrl?: string;
+    showTriggerButton?: boolean;
+    injectImmediately?: boolean;
+    sidecar?: string;
+    anchor?: Anchor;
+    debug?: boolean;
+}): Promise<void>;

package/dist/integrations/console/console-tab.d.ts

@@ -0,0 +1,6 @@
+import { ConsoleMessage } from './types';
+type Props = {
+    processedEvents?: ConsoleMessage[];
+};
+export default function ConsoleTab({ processedEvents }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/integrations/console/index.d.ts

@@ -0,0 +1,18 @@
+import ConsoleTab from './console-tab';
+import { ConsoleMessage } from './types';
+export default function consoleIntegration(): {
+    name: string;
+    forwardedContentType: string[];
+    tabs: ({ processedEvents }: {
+        processedEvents: any[];
+    }) => {
+        id: string;
+        title: string;
+        notificationCount: number;
+        content: typeof ConsoleTab;
+    }[];
+    setup: () => void;
+    processEvent({ data }: import("../integration").RawEventContext): {
+        event: ConsoleMessage;
+    };
+};

package/dist/integrations/console/types.d.ts

@@ -0,0 +1,7 @@
+export type ConsoleMessage = {
+    type: Level;
+    args: string[];
+    msg: string;
+    sessionId: string;
+};
+export type Level = 'log' | 'warn' | 'error';

package/dist/integrations/integration.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="react" />
+export type Integration<T = any> = {
+    /**
+     * Name of the integration
+     */
+    name: string;
+    /**
+     * The content-type http headers determining which events dispatched to spotlight
+     * events should be forwarded to this integration.
+     *
+     * For example: ["application/x-sentry-envelope"]
+     */
+    forwardedContentType?: string[];
+    /**
+     * A function returning an array of tabs to be displayed in the UI.
+     *
+     * @param context contains the processed events for the tabs. Use this information to
+     * e.g. update the notification count badge of the tab.
+     */
+    tabs?: TabsCreationFunction<T>;
+    /**
+     * Setup hook called when Spotlight is initialized.
+     *
+     * Use this hook to setup any global state, instrument handlers, etc.
+     */
+    setup?: () => void | Promise<void>;
+    /**
+     * Hook called whenever spotlight forwards a new raw event to this integration.
+     *
+     * Use this hook to process and convert the raw request payload (string) to a
+     * data structure that your integration works with in the UI.
+     *
+     * If you want to disregard the sent event, simply return `undefined`.
+     *
+     * The returned object will be passed to your tabs function.
+     */
+    processEvent?: (eventContext: RawEventContext) => ProcessedEventContainer<T> | undefined;
+};
+export type IntegrationTab<T> = {
+    /**
+     * Id of the tab. This needs to be a unique name.
+     */
+    id: string;
+    /**
+     * Title of the tab. This is what will be displayed in the UI.
+     */
+    title: string;
+    /**
+     * If this property is set, a count badge will be displayed
+     * next to the tab title with the specified value.
+     */
+    notificationCount?: number;
+    /**
+     * JSX content of the tab. Go crazy, this is all yours!
+     */
+    content?: React.ComponentType<{
+        processedEvents: T[];
+    }>;
+    onSelect?: () => void;
+    active?: boolean;
+};
+export type ProcessedEventContainer<T> = {
+    /**
+     * The processed event data to be passed to your tabs.
+     */
+    event: T;
+    /**
+     * A level indicating the impact or severity of the processed event. Set this to
+     * 'severe' if the event is critical and users should be aware of it (e.g. a thrown error).
+     *
+     * If this is set to 'severe', a red notification count badge will be displayed
+     * next to the spotlight trigger button in the UI.
+     *
+     * @default value is 'default'
+     */
+    severity?: Severity;
+};
+export type Severity = 'default' | 'severe';
+export type IntegrationData<T> = Record<string, ProcessedEventContainer<T>[]>;
+type TabsContext<T> = {
+    processedEvents: T[];
+};
+type TabsCreationFunction<T> = (context: TabsContext<T>) => IntegrationTab<T>[];
+export type RawEventContext = {
+    /**
+     * The content-type header of the event
+     */
+    contentType: string;
+    /**
+     * The raw data in string form of the request.
+     * Use this function to parse and process the raw data it to whatever data structure
+     * you expect for the given `contentType`.
+     *
+     * Return the processed object or undefined if the event should be ignored.
+     */
+    data: string;
+};
+export declare function initIntegrations(integrations?: Integration[]): Promise<Integration[]>;
+export {};

package/dist/integrations/sentry/components/DateTime.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export default function DateTime({ date, ...props }: {
+    date: string | number | Date;
+} & React.ComponentProps<'time'>): import("react/jsx-runtime").JSX.Element | null;

package/dist/integrations/sentry/components/EventBreadcrumbs.d.ts

@@ -0,0 +1,4 @@
+import { SentryEvent } from '../types';
+export default function EventBreadcrumbs({ event }: {
+    event: SentryEvent;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/EventContexts.d.ts

@@ -0,0 +1,4 @@
+import { SentryEvent } from '../types';
+export default function EventContexts({ event }: {
+    event: SentryEvent;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/EventDetails.d.ts

@@ -0,0 +1 @@
+export default function EventDetails(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/EventList.d.ts

@@ -0,0 +1 @@
+export default function EventList(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/Events/Error/Frame.d.ts

@@ -0,0 +1,5 @@
+import { EventFrame } from '../../../types';
+export default function Frame({ frame, defaultExpand }: {
+    frame: EventFrame;
+    defaultExpand: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/Events/Error.d.ts

@@ -0,0 +1,10 @@
+import { SentryErrorEvent } from '../../types';
+export declare function ErrorTitle({ event }: {
+    event: SentryErrorEvent;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ErrorSummary({ event }: {
+    event: SentryErrorEvent;
+}): import("react/jsx-runtime").JSX.Element;
+export default function Error({ event }: {
+    event: SentryErrorEvent;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/PlatformIcon.d.ts

@@ -0,0 +1,9 @@
+import { SentryEvent } from '../types';
+import { ComponentPropsWithoutRef } from 'react';
+type Platform = 'python' | 'javascript' | 'node' | 'ruby' | string;
+export default function PlatformIcon({ platform, event, size, ...props }: ComponentPropsWithoutRef<'svg'> & {
+    size?: number;
+    platform?: Platform;
+    event?: SentryEvent;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/integrations/sentry/components/SdkList.d.ts

@@ -0,0 +1 @@
+export default function SdkList(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/SpanDetails.d.ts

@@ -0,0 +1,7 @@
+import { Span, TraceContext } from '../types';
+export default function SpanDetails({ traceContext, span, startTimestamp, totalDuration, }: {
+    traceContext: TraceContext;
+    span: Span;
+    startTimestamp: number;
+    totalDuration: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/SpanTree.d.ts

@@ -0,0 +1,8 @@
+import { Span, TraceContext } from '../types';
+export default function SpanTree({ traceContext, tree, startTimestamp, totalDuration, depth, }: {
+    traceContext: TraceContext;
+    tree: Span[];
+    startTimestamp: number;
+    totalDuration: number;
+    depth?: number;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/integrations/sentry/components/Time.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export default function Time({ date, ...props }: {
+    date: string | number | Date;
+} & React.ComponentProps<'time'>): import("react/jsx-runtime").JSX.Element | null;

package/dist/integrations/sentry/components/TimeSince.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export default function TimeSince({ date, ...props }: {
+    date: string | number | Date;
+} & React.ComponentProps<'time'>): import("react/jsx-runtime").JSX.Element | null;

package/dist/integrations/sentry/components/TraceDetails.d.ts

@@ -0,0 +1 @@
+export default function TraceDetails(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/components/TraceList.d.ts

@@ -0,0 +1 @@
+export default function TraceList(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/data/sentryDataCache.d.ts

@@ -0,0 +1,33 @@
+import { Envelope } from '@sentry/types';
+import { Sdk, SentryEvent, Span, Trace } from '../types';
+type OnlineSubscription = ['online', (status: boolean) => void];
+type EventSubscription = ['event', (event: SentryEvent) => void];
+type TraceSubscription = ['trace', (trace: Trace) => void];
+type Subscription = OnlineSubscription | EventSubscription | TraceSubscription;
+declare class SentryDataCache {
+    protected events: SentryEvent[];
+    protected sdks: Sdk[];
+    protected traces: Trace[];
+    protected tracesById: {
+        [id: string]: Trace;
+    };
+    protected subscribers: Map<string, Subscription>;
+    constructor(initial?: (SentryEvent & {
+        event_id?: string;
+    })[]);
+    inferSdkFromEvent(event: SentryEvent): Sdk;
+    pushEnvelope(envelope: Envelope): void;
+    pushEvent(event: SentryEvent & {
+        event_id?: string;
+    }): void;
+    getEvents(): SentryEvent[];
+    getTraces(): Trace[];
+    getSdks(): Sdk[];
+    getEventById(id: string): SentryEvent | undefined;
+    getTraceById(id: string): Trace;
+    getEventsByTrace(traceId: string, spanId?: string | null): SentryEvent[];
+    getSpanById(traceId: string, spanId: string): Span | undefined;
+    subscribe(...args: Subscription): () => void;
+}
+declare const _default: SentryDataCache;
+export default _default;

package/dist/integrations/sentry/data/sentryDataCache.test.d.ts

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

package/dist/integrations/sentry/data/sentryEventsContext.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+import { SentryEvent } from '../types';
+export declare const SentryEventsContext: React.Context<SentryEvent[]>;
+export declare const SentryEventsContextProvider: React.FC<{
+    children: ReactNode;
+}>;

package/dist/integrations/sentry/data/useSentryEvents.d.ts

@@ -0,0 +1 @@
+export declare const useSentryEvents: () => import("../types").SentryEvent[];

package/dist/integrations/sentry/data/useSentrySdks.d.ts

@@ -0,0 +1 @@
+export declare const useSentrySdks: () => import("../types").Sdk[];

package/dist/integrations/sentry/data/useSentryTraces.d.ts

@@ -0,0 +1 @@
+export declare const useSentryTraces: () => import("../types").Trace[];

package/dist/integrations/sentry/index.d.ts

@@ -0,0 +1,28 @@
+import type { Envelope } from '@sentry/types';
+import type { RawEventContext, Severity } from '../integration';
+import ErrorsTab from './tabs/ErrorsTab';
+import SdksTab from './tabs/SdksTab';
+export default function sentryIntegration(): {
+    name: string;
+    forwardedContentType: string[];
+    setup: () => void;
+    processEvent: (event: RawEventContext) => {
+        event: Envelope;
+        severity: Severity;
+    };
+    tabs: () => ({
+        id: string;
+        title: string;
+        notificationCount: number;
+        content: typeof ErrorsTab;
+    } | {
+        id: string;
+        title: string;
+        content: typeof SdksTab;
+        notificationCount?: undefined;
+    })[];
+};
+export declare function processEnvelope({ data }: RawEventContext): {
+    event: Envelope;
+    severity: Severity;
+};

package/dist/integrations/sentry/index.test.d.ts

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

package/dist/integrations/sentry/sentry-integration.d.ts

@@ -0,0 +1,5 @@
+import { EventProcessor, Hub, Integration } from '@sentry/types';
+export declare class Spotlight implements Integration {
+    name: string;
+    setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void;
+}

package/dist/integrations/sentry/tabs/ErrorsTab.d.ts

@@ -0,0 +1 @@
+export default function ErrorsTab(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/tabs/SdksTab.d.ts

@@ -0,0 +1 @@
+export default function SdksTab(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/tabs/TracesTab.d.ts

@@ -0,0 +1 @@
+export default function ErrorsTab(): import("react/jsx-runtime").JSX.Element;

package/dist/integrations/sentry/types.d.ts

@@ -0,0 +1,118 @@
+export type FrameVars = {
+    [key: string]: string;
+};
+export type EventFrame = {
+    filename: string;
+    abs_path?: string;
+    function?: string;
+    module?: string;
+    lineno?: number;
+    colno?: number;
+    pre_context?: string[];
+    post_context?: string[];
+    context_line?: string;
+    vars?: FrameVars;
+    in_app?: boolean;
+};
+export type EventStacktrace = {
+    frames: EventFrame[];
+};
+export type EventExceptionValue = {
+    type: string;
+    value: string;
+    stacktrace?: EventStacktrace;
+};
+export type EventException = {
+    values: EventExceptionValue[];
+    value: undefined;
+} | {
+    values: undefined;
+    value: EventExceptionValue;
+};
+export type Breadcrumbs = {
+    values: {
+        message: string;
+        category: string;
+        timestamp: string;
+        type: string | 'default';
+    }[];
+};
+type CommonEventAttrs = {
+    event_id: string;
+    timestamp: number;
+    breadcrumbs?: Breadcrumbs;
+    transaction?: string;
+    environment?: string;
+    platform?: string;
+    server_name?: string;
+    release?: string;
+    start_timestamp?: number;
+    contexts?: Contexts;
+    tags?: Tags;
+    extra?: {
+        [key: string]: string | number;
+    };
+    sdk?: Sdk;
+};
+export type Context = {
+    [key: string]: string | number;
+};
+export type TraceContext = {
+    trace_id: string;
+    span_id: string;
+    parent_span_id?: string | null;
+    op: string;
+    description?: string | null;
+    status: 'ok' | string;
+};
+export type Contexts = {
+    trace?: TraceContext;
+} & {
+    [key: string]: Context;
+};
+export type Tags = {
+    [key: string]: string;
+};
+export type SentryErrorEvent = CommonEventAttrs & {
+    type?: 'error' | 'default';
+    exception: EventException;
+};
+export type Span = {
+    trace_id: string;
+    span_id: string;
+    parent_span_id?: string | null;
+    op: string;
+    description?: string | null;
+    start_timestamp: number;
+    tags?: Tags | null;
+    timestamp: number;
+    status: 'ok' | string;
+    transaction?: SentryTransactionEvent;
+    children?: Span[];
+};
+export type SentryTransactionEvent = CommonEventAttrs & {
+    type: 'transaction';
+    spans: Span[];
+    start_timestamp: string;
+    contexts: Contexts & {
+        trace: TraceContext;
+    };
+};
+export type SentryEvent = SentryErrorEvent | SentryTransactionEvent;
+export type Trace = TraceContext & {
+    transactions: SentryTransactionEvent[];
+    errors: number;
+    start_timestamp: number;
+    timestamp: number;
+    status: string;
+    rootTransaction: SentryTransactionEvent | null;
+    rootTransactionName: string;
+    spans: Span[];
+    spanTree: Span[];
+};
+export type Sdk = {
+    name: string;
+    version: string;
+    lastSeen: number;
+};
+export {};

package/dist/integrations/sentry/utils/duration.d.ts

@@ -0,0 +1,2 @@
+export declare function getDuration(start: string | number, end: string | number): number;
+export declare function getSpanDurationClassName(duration: number): "text-red-400" | "text-orange-400" | "text-yellow-400" | undefined;

package/dist/integrations/sentry/utils/traces.d.ts

@@ -0,0 +1,2 @@
+import { Span } from '../types';
+export declare function groupSpans(spans: Span[]): Span[];

package/dist/integrations/sentry/utils/traces.test.d.ts

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

package/dist/integrations/vite-inspect/index.d.ts

@@ -0,0 +1,10 @@
+import ViteInspect from './vite-inspect';
+export default function viteInspectIntegration(): {
+    name: string;
+    tabs: () => {
+        id: string;
+        title: string;
+        content: typeof ViteInspect;
+    }[];
+    setup: () => void;
+};

package/dist/integrations/vite-inspect/vite-inspect.d.ts

@@ -0,0 +1 @@
+export default function ViteInspect(): import("react/jsx-runtime").JSX.Element;

package/dist/lib/classNames.d.ts

@@ -0,0 +1 @@
+export default function classNames(...classes: (string | undefined | boolean | null)[]): string;

package/dist/lib/eventTarget.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the global singleton event target for spotlight.
+ *
+ * This is used to communicate between spotlight and the outside world.
+ * To avoid instances where multiple versions of spotlight code are loaded,
+ * we put the target onto the global object.
+ *
+ * @see https://github.com/getsentry/spotlight/issues/68
+ *
+ * In case of window being undefined (e.g. in SSR), we return a fallback event target.
+ * which is local to one spotlight code instance.
+ */
+export declare function getSpotlightEventTarget(): EventTarget;

package/dist/lib/logger.d.ts

@@ -0,0 +1,3 @@
+export declare function activateLogger(): void;
+export declare function deactivateLogger(): void;
+export declare function log(...args: unknown[]): void;

package/dist/lib/useKeyPress.d.ts

@@ -0,0 +1,6 @@
+/**
+ * useKeyPress
+ * @param {string} key - the name of the key to respond to, compared against event.key
+ * @param {function} action - the action to perform on key press
+ */
+export default function useKeyPress(key: string, action: () => void, propagate?: boolean): void;

package/dist/lib/uuid.d.ts

@@ -0,0 +1 @@
+export declare function generate_uuidv4(): string;

package/dist/sentry-spotlight.d.ts

@@ -0,0 +1 @@
+export * from './index'