@sentry/svelte 7.67.0-beta.0 → 7.68.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/svelte",
-  "version": "7.67.0-beta.0",
+  "version": "7.68.0",
   "description": "Official Sentry SDK for Svelte",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/svelte",
@@ -14,7 +14,7 @@
   "types": "types/index.d.ts",
   "typesVersions": {
     "<4.9": {
-      "build/types/index.d.ts": [
+      "types/index.d.ts": [
         "types-ts3.8/index.d.ts"
       ]
     }
@@ -23,9 +23,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/browser": "7.67.0-beta.0",
-    "@sentry/types": "7.67.0-beta.0",
-    "@sentry/utils": "7.67.0-beta.0",
+    "@sentry/browser": "7.68.0",
+    "@sentry/types": "7.68.0",
+    "@sentry/utils": "7.68.0",
     "magic-string": "^0.30.0",
     "tslib": "^2.4.1 || ^1.9.3"
   },

package/types-ts3.8/config.d.ts

@@ -0,0 +1,11 @@
+import { SentrySvelteConfigOptions, SvelteConfig } from './types';
+/**
+ * Add Sentry options to the Svelte config to be exported from the user's `svelte.config.js` file.
+ *
+ * @param originalConfig The existing config to be exported prior to adding Sentry
+ * @param sentryOptions The configuration of the Sentry-added options
+ *
+ * @return The wrapped and modified config to be exported
+ */
+export declare function withSentryConfig(originalConfig: SvelteConfig, sentryOptions?: SentrySvelteConfigOptions): SvelteConfig;
+//# sourceMappingURL=config.d.ts.map

package/types-ts3.8/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const UI_SVELTE_INIT = "ui.svelte.init";
+export declare const UI_SVELTE_UPDATE = "ui.svelte.update";
+export declare const DEFAULT_COMPONENT_NAME = "Svelte Component";
+//# sourceMappingURL=constants.d.ts.map

package/types-ts3.8/index.d.ts

@@ -0,0 +1,7 @@
+export { ComponentTrackingInitOptions as ComponentTrackingOptions, TrackComponentOptions as TrackingOptions, } from './types';
+export * from '@sentry/browser';
+export { init } from './sdk';
+export { componentTrackingPreprocessor } from './preprocessors';
+export { trackComponent } from './performance';
+export { withSentryConfig } from './config';
+//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/performance.d.ts

@@ -0,0 +1,10 @@
+import { TrackComponentOptions } from './types';
+/**
+ * Tracks the Svelte component's intialization and mounting operation as well as
+ * updates and records them as spans.
+ * This function is injected automatically into your Svelte components' code
+ * if you are using the Sentry componentTrackingPreprocessor.
+ * Alternatively, you can call it yourself if you don't want to use the preprocessor.
+ */
+export declare function trackComponent(options?: TrackComponentOptions): void;
+//# sourceMappingURL=performance.d.ts.map

package/types-ts3.8/preprocessors.d.ts

@@ -0,0 +1,13 @@
+import { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
+import { ComponentTrackingInitOptions } from './types';
+export declare const defaultComponentTrackingOptions: Required<ComponentTrackingInitOptions>;
+export declare const FIRST_PASS_COMPONENT_TRACKING_PREPROC_ID = "FIRST_PASS_COMPONENT_TRACKING_PREPROCESSOR";
+/**
+ * Svelte Preprocessor to inject Sentry performance monitoring related code
+ * into Svelte components.
+ *
+ * @deprecated Use `withSentryConfig` which is the new way of making compile-time modifications
+ *             to Svelte apps going forward.
+ */
+export declare function componentTrackingPreprocessor(options?: ComponentTrackingInitOptions): PreprocessorGroup;
+//# sourceMappingURL=preprocessors.d.ts.map

package/types-ts3.8/sdk.d.ts

@@ -0,0 +1,23 @@
+import { BrowserOptions } from '@sentry/browser';
+/**
+ * Inits the Svelte SDK
+ */
+export declare function init(options: BrowserOptions): void;
+/**
+ * Adds a global event processor to detect if the SDK is initialized in a SvelteKit frontend,
+ * in which case we add SvelteKit an event.modules entry to outgoing events.
+ * SvelteKit detection is performed only once, when the event processor is called for the
+ * first time. We cannot perform this check upfront (directly when init is called) because
+ * at this time, the HTML element might not yet be accessible.
+ */
+export declare function detectAndReportSvelteKit(): void;
+/**
+ * To actually detect a SvelteKit frontend, we search the DOM for a special
+ * div that's inserted by SvelteKit when the page is rendered. It's identifyed
+ * by its id, 'svelte-announcer', and it's used to improve page accessibility.
+ * This div is not present when only using Svelte without SvelteKit.
+ *
+ * @see https://github.com/sveltejs/kit/issues/307 for more information
+ */
+export declare function isSvelteKitApp(): boolean;
+//# sourceMappingURL=sdk.d.ts.map

package/types-ts3.8/types.d.ts

@@ -0,0 +1,56 @@
+import { CompileOptions } from 'svelte/types/compiler';
+import { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
+export interface SentryPreprocessorGroup extends PreprocessorGroup {
+    sentryId?: string;
+}
+/**
+ * The object exported from `svelte.config.js`
+ */
+export type SvelteConfig = {
+    [key: string]: unknown;
+    preprocess?: PreprocessorGroup[] | PreprocessorGroup;
+    compilerOptions?: CompileOptions;
+};
+/**
+ * Options users can provide to `withSentryConfig` to customize what Sentry adds too the Svelte config
+ */
+export type SentrySvelteConfigOptions = {
+    componentTracking?: ComponentTrackingInitOptions;
+};
+export type SpanOptions = {
+    /**
+     * If true, a span is recorded between a component's intialization and its
+     * onMount lifecycle hook. This span tells how long it takes a component
+     * to be created and inserted into the DOM.
+     *
+     * Defaults to true if component tracking is enabled
+     */
+    trackInit?: boolean;
+    /**
+     * If true, a span is recorded between a component's beforeUpdate and afterUpdate
+     * lifecycle hooks.
+     *
+     * Defaults to true if component tracking is enabled
+     */
+    trackUpdates?: boolean;
+};
+/**
+ * Control which components and which operations should be tracked
+ * and recorded as spans
+ */
+export type ComponentTrackingInitOptions = {
+    /**
+     * Control if all your Svelte components should be tracked or only a specified list
+     * of components.
+     * If set to true, all components will be tracked.
+     * If you only want to track a selection of components, specify the component names
+     * as an array.
+     *
+     * Defaults to true if the preprocessor is used
+     */
+    trackComponents?: boolean | string[];
+} & SpanOptions;
+export type TrackComponentOptions = {
+    componentName?: string;
+} & SpanOptions;
+//# sourceMappingURL=types.d.ts.map