@getmicdrop/svelte-components 1.0.1

package/README.md

@@ -0,0 +1,98 @@
+# @micdrop/components
+
+Shared component library for Micdrop applications.
+
+## Installation
+
+```bash
+npm install @micdrop/components
+```
+
+## Usage
+
+```svelte
+<script>
+  import { Button, Input, Modal } from '@micdrop/components';
+  import '@micdrop/components/styles';
+</script>
+
+<Button variant="primary">Click me</Button>
+```
+
+## Development
+
+### Install dependencies
+```bash
+npm install
+```
+
+### Run Storybook
+```bash
+npm run storybook
+```
+
+### Run tests
+```bash
+npm test
+npm run test:watch  # Watch mode
+npm run test:ui     # UI mode
+```
+
+### Build
+```bash
+npm run build
+```
+
+## Components
+
+### Core UI Components
+- **Alert** - Alert notifications
+- **Badge** - Badge display
+- **Breadcrumb** - Navigation breadcrumb
+- **Button** - Primary button with variants
+- **Card** - Card container
+- **Spinner** - Loading spinner
+- **Toaster** - Toast notifications
+
+### Form Components
+- **Input** - Text input with validation
+- **Select** - Dropdown select
+- **MultiSelect** - Multi-select dropdown
+- **GenderInput** - Gender selector
+- **EthnicityDropdown** - Ethnicity selector
+- **PlaceAutocomplete** - Google Places autocomplete
+- **CropImage** - Image cropping utility
+
+### Layout Components
+- **Header** - Application header
+- **Sidebar** - Navigation sidebar
+- **Modal** - Modal dialog
+- **ConfirmationModal** - Confirmation modal
+
+### Calendar Components
+- **QuarterView** - Calendar quarter view
+
+### Icon Components
+- 26 icon components available in `Icons/` directory
+
+### Page Components
+Located in `pages/` directory:
+- **performers/** - Performer-related components
+- **profile/** - Profile components
+- **settings/** - Settings components
+- **shows/** - Show/event components
+
+## Testing
+
+All components include:
+- Unit tests using Vitest
+- Storybook stories for visual testing
+- Type definitions
+
+## Version History
+
+### 1.0.0 (Upcoming)
+- Initial release
+- Core components from performersportal
+- Full test coverage
+- Storybook documentation

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export const API_BASE_URL: any;
+export const PUBLIC_GOOGLE_MAPS_API_KEY: any;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/lib/config.js"],"names":[],"mappings":"AAAA,+BACiE;AAEjE,6CAE4C"}

package/dist/config.js

@@ -0,0 +1,6 @@
+export const API_BASE_URL =
+  import.meta.env.VITE_API_BASE_URL || 'https://get-micdrop.com';
+
+export const PUBLIC_GOOGLE_MAPS_API_KEY =
+  import.meta.env.VITE_PUBLIC_GOOGLE_MAPS_API_KEY ||
+  'AIzaSyCFB0-9qay7P0jZZDw93SsTnyLtZDlch7Q';

package/dist/config.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.spec.d.ts.map

package/dist/config.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.spec.d.ts","sourceRoot":"","sources":["../src/lib/config.spec.js"],"names":[],"mappings":""}

package/dist/config.spec.js

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('config.js', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('exports API_BASE_URL', async () => {
+    const config = await import('./config.js');
+    expect(config.API_BASE_URL).toBeDefined();
+    expect(typeof config.API_BASE_URL).toBe('string');
+  });
+
+  it('exports PUBLIC_GOOGLE_MAPS_API_KEY', async () => {
+    const config = await import('./config.js');
+    expect(config.PUBLIC_GOOGLE_MAPS_API_KEY).toBeDefined();
+    expect(typeof config.PUBLIC_GOOGLE_MAPS_API_KEY).toBe('string');
+  });
+
+  it('uses default API_BASE_URL when env var not set', async () => {
+    const config = await import('./config.js');
+    expect(config.API_BASE_URL).toContain('get-micdrop.com');
+  });
+
+  it('uses default Google Maps key when env var not set', async () => {
+    const config = await import('./config.js');
+    expect(config.PUBLIC_GOOGLE_MAPS_API_KEY).toContain('AIzaSy');
+  });
+});

package/dist/constants/formOptions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Form options for dropdowns used across the performers portal.
+ * Use these with Select and MultiSelect components instead of
+ * creating wrapper components like GenderInput or EthnicityDropdown.
+ *
+ * Example:
+ *   import { GENDER_OPTIONS } from './formOptions';
+ *   <Select items={GENDER_OPTIONS} label="Gender" />
+ */
+export const GENDER_OPTIONS: {
+    name: string;
+    value: number;
+}[];
+export const ETHNICITY_OPTIONS: {
+    name: string;
+    value: number;
+}[];
+//# sourceMappingURL=formOptions.d.ts.map

package/dist/constants/formOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formOptions.d.ts","sourceRoot":"","sources":["../../src/lib/constants/formOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;IAIE;AAEF;;;IAQE"}

package/dist/constants/formOptions.js

@@ -0,0 +1,25 @@
+/**
+ * Form options for dropdowns used across the performers portal.
+ * Use these with Select and MultiSelect components instead of
+ * creating wrapper components like GenderInput or EthnicityDropdown.
+ *
+ * Example:
+ *   import { GENDER_OPTIONS } from './formOptions';
+ *   <Select items={GENDER_OPTIONS} label="Gender" />
+ */
+
+export const GENDER_OPTIONS = [
+  { name: "Male", value: 1 },
+  { name: "Female", value: 2 },
+  { name: "Non-Binary", value: 3 },
+];
+
+export const ETHNICITY_OPTIONS = [
+  { name: "American Indian or Alaska Native", value: 0 },
+  { name: "Asian", value: 1 },
+  { name: "Black or African American", value: 2 },
+  { name: "Hispanic or Latino", value: 3 },
+  { name: "Middle Eastern or North African", value: 4 },
+  { name: "Native Hawaiian or Pacific Islander", value: 5 },
+  { name: "White", value: 6 },
+];

package/dist/constants/formOptions.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formOptions.spec.d.ts.map

package/dist/constants/formOptions.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formOptions.spec.d.ts","sourceRoot":"","sources":["../../src/lib/constants/formOptions.spec.js"],"names":[],"mappings":""}

package/dist/constants/formOptions.spec.js

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { GENDER_OPTIONS, ETHNICITY_OPTIONS } from './formOptions.js';
+
+describe('formOptions', () => {
+  describe('GENDER_OPTIONS', () => {
+    it('exports gender options array', () => {
+      expect(GENDER_OPTIONS).toBeDefined();
+      expect(Array.isArray(GENDER_OPTIONS)).toBe(true);
+    });
+
+    it('has three options', () => {
+      expect(GENDER_OPTIONS.length).toBe(3);
+    });
+
+    it('contains Male option with value 1', () => {
+      const male = GENDER_OPTIONS.find(opt => opt.name === 'Male');
+      expect(male).toBeDefined();
+      expect(male.value).toBe(1);
+    });
+
+    it('contains Female option with value 2', () => {
+      const female = GENDER_OPTIONS.find(opt => opt.name === 'Female');
+      expect(female).toBeDefined();
+      expect(female.value).toBe(2);
+    });
+
+    it('contains Non-Binary option with value 3', () => {
+      const nonBinary = GENDER_OPTIONS.find(opt => opt.name === 'Non-Binary');
+      expect(nonBinary).toBeDefined();
+      expect(nonBinary.value).toBe(3);
+    });
+
+    it('each option has name and value properties', () => {
+      GENDER_OPTIONS.forEach(option => {
+        expect(option).toHaveProperty('name');
+        expect(option).toHaveProperty('value');
+        expect(typeof option.name).toBe('string');
+        expect(typeof option.value).toBe('number');
+      });
+    });
+  });
+
+  describe('ETHNICITY_OPTIONS', () => {
+    it('exports ethnicity options array', () => {
+      expect(ETHNICITY_OPTIONS).toBeDefined();
+      expect(Array.isArray(ETHNICITY_OPTIONS)).toBe(true);
+    });
+
+    it('has seven options', () => {
+      expect(ETHNICITY_OPTIONS.length).toBe(7);
+    });
+
+    it('contains all expected ethnicities', () => {
+      const names = ETHNICITY_OPTIONS.map(opt => opt.name);
+      expect(names).toContain('American Indian or Alaska Native');
+      expect(names).toContain('Asian');
+      expect(names).toContain('Black or African American');
+      expect(names).toContain('Hispanic or Latino');
+      expect(names).toContain('Middle Eastern or North African');
+      expect(names).toContain('Native Hawaiian or Pacific Islander');
+      expect(names).toContain('White');
+    });
+
+    it('has values 0 through 6', () => {
+      const values = ETHNICITY_OPTIONS.map(opt => opt.value).sort((a, b) => a - b);
+      expect(values).toEqual([0, 1, 2, 3, 4, 5, 6]);
+    });
+
+    it('each option has name and value properties', () => {
+      ETHNICITY_OPTIONS.forEach(option => {
+        expect(option).toHaveProperty('name');
+        expect(option).toHaveProperty('value');
+        expect(typeof option.name).toBe('string');
+        expect(typeof option.value).toBe('number');
+      });
+    });
+
+    it('American Indian or Alaska Native has value 0', () => {
+      const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'American Indian or Alaska Native');
+      expect(option.value).toBe(0);
+    });
+
+    it('White has value 6', () => {
+      const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'White');
+      expect(option.value).toBe(6);
+    });
+  });
+});

package/dist/telemetry.d.ts

@@ -0,0 +1,13 @@
+export function initTelemetry(): void;
+export function startSpan(name: any, options?: {}): any;
+export function endSpan(span: any, status?: {
+    code: number;
+}): void;
+export function trackPageView(pagePath: any, pageTitle: any): void;
+export function trackEvent(eventName: any, attributes?: {}): void;
+export function trackPerformerAction(action: any, metadata?: {}): void;
+export function trackError(error: any, context?: {}): void;
+export function trackAPICall(method: any, endpoint: any, status: any, duration: any, attributes?: {}): void;
+export function trackUserAction(action: any, metadata?: {}): void;
+export function shutdownTelemetry(): Promise<void>;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/lib/telemetry.js"],"names":[],"mappings":"AAkCA,sCA4HC;AAGD,wDAcC;AAGD;;SAMC;AAGD,mEAeC;AAGD,kEAcC;AAGD,uEAeC;AAGD,2DAmBC;AAGD,4GAkBC;AAGD,kEAeC;AAGD,mDASC"}

package/dist/telemetry.js

@@ -0,0 +1,358 @@
+import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT } from '@opentelemetry/semantic-conventions';
+import { DocumentLoadInstrumentation } from '@opentelemetry/instrumentation-document-load';
+import { FetchInstrumentation } from '@opentelemetry/instrumentation-fetch';
+import { XMLHttpRequestInstrumentation } from '@opentelemetry/instrumentation-xml-http-request';
+import { UserInteractionInstrumentation } from '@opentelemetry/instrumentation-user-interaction';
+import { ZoneContextManager } from '@opentelemetry/context-zone';
+import { B3Propagator } from '@opentelemetry/propagator-b3';
+
+// Telemetry configuration from environment or defaults
+const TELEMETRY_CONFIG = {
+  serviceName: import.meta.env.VITE_OTEL_SERVICE_NAME || 'jetbook-performersportal',
+  serviceVersion: import.meta.env.VITE_OTEL_SERVICE_VERSION || '1.0.0',
+  environment: import.meta.env.VITE_ENVIRONMENT || 'development',
+  otlpEndpoint: import.meta.env.VITE_OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',
+  tracesEnabled: import.meta.env.VITE_OTEL_TRACES_ENABLED !== 'false',
+  sampleRate: parseFloat(import.meta.env.VITE_OTEL_TRACES_SAMPLER_ARG || '0.1'), // 10% sampling by default
+  consoleDebug: import.meta.env.VITE_OTEL_DEBUG === 'true'
+};
+
+let tracer = null;
+let tracerProvider = null;
+
+// Helper to log telemetry events when debugging
+function debugLog(message, data) {
+  if (TELEMETRY_CONFIG.consoleDebug) {
+    console.log(`[Telemetry] ${message}`, data || '');
+  }
+}
+
+// Initialize OpenTelemetry
+export function initTelemetry() {
+  if (!TELEMETRY_CONFIG.tracesEnabled) {
+    console.log('[Telemetry] Tracing is disabled');
+    return;
+  }
+
+  try {
+    // Create resource with service information
+    const resource = new Resource({
+        [SEMRESATTRS_SERVICE_NAME]: TELEMETRY_CONFIG.serviceName,
+        [SEMRESATTRS_SERVICE_VERSION]: TELEMETRY_CONFIG.serviceVersion,
+        [SEMRESATTRS_DEPLOYMENT_ENVIRONMENT]: TELEMETRY_CONFIG.environment,
+        'browser.user_agent': navigator.userAgent,
+        'browser.language': navigator.language,
+        'browser.platform': navigator.platform
+    });
+
+    // Create tracer provider
+    tracerProvider = new WebTracerProvider({
+      resource,
+      sampler: {
+        shouldSample: () => {
+          return {
+            decision: Math.random() < TELEMETRY_CONFIG.sampleRate ? 1 : 0,
+            attributes: []
+          };
+        }
+      }
+    });
+
+    // Configure OTLP exporter
+    const exporter = new OTLPTraceExporter({
+      url: TELEMETRY_CONFIG.otlpEndpoint,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // Add batch span processor
+    tracerProvider.addSpanProcessor(new BatchSpanProcessor(exporter, {
+      maxQueueSize: 100,
+      maxExportBatchSize: 50,
+      scheduledDelayMillis: 500,
+      exportTimeoutMillis: 30000
+    }));
+
+    // Set global provider
+    tracerProvider.register({
+      contextManager: new ZoneContextManager(),
+      propagator: new B3Propagator()
+    });
+
+    // Enable browser instrumentations
+    // These auto-register with the global tracer provider when instantiated and enabled
+    new DocumentLoadInstrumentation({
+      applyCustomAttributesOnSpan: {
+        documentLoad: (span) => {
+          span.setAttribute('page.path', window.location.pathname);
+          span.setAttribute('page.search', window.location.search);
+          span.setAttribute('page.hash', window.location.hash);
+          span.setAttribute('portal.type', 'performers');
+        },
+        documentFetch: (span) => {
+          span.setAttribute('document.referrer', document.referrer);
+        }
+      }
+    }).enable();
+
+    new FetchInstrumentation({
+      propagateTraceHeaderCorsUrls: [
+        /^http:\/\/localhost:8080\/.*/,
+        /^https:\/\/api\.jetbook\.com\/.*/,
+        /^https:\/\/.*\.get-micdrop\.com\/.*/
+      ],
+      clearTimingResources: true,
+      applyCustomAttributesOnSpan: (span, request, response) => {
+        const url = new URL(request.url || '');
+        span.setAttribute('http.url.pathname', url.pathname);
+        span.setAttribute('http.url.search', url.search);
+        span.setAttribute('portal.type', 'performers');
+
+        if (response) {
+          span.setAttribute('http.response.status', response.status);
+          span.setAttribute('http.response.content_length', response.headers?.get('content-length') || 0);
+        }
+      }
+    }).enable();
+
+    new XMLHttpRequestInstrumentation({
+      propagateTraceHeaderCorsUrls: [
+        /^http:\/\/localhost:8080\/.*/,
+        /^https:\/\/api\.jetbook\.com\/.*/,
+        /^https:\/\/.*\.get-micdrop\.com\/.*/
+      ],
+      clearTimingResources: true
+    }).enable();
+
+    new UserInteractionInstrumentation({
+      eventNames: ['click', 'submit', 'change'],
+      shouldPreventSpanCreation: (eventType, element, span) => {
+        // Skip telemetry for certain elements
+        if (element.classList?.contains('no-telemetry')) {
+          return true;
+        }
+        // Skip very frequent events
+        if (eventType === 'change' && element.tagName === 'INPUT' && element.type === 'text') {
+          return true;
+        }
+        return false;
+      }
+    }).enable();
+
+    // Get tracer instance
+    tracer = tracerProvider.getTracer(
+      TELEMETRY_CONFIG.serviceName,
+      TELEMETRY_CONFIG.serviceVersion
+    );
+
+    debugLog('Telemetry initialized', TELEMETRY_CONFIG);
+    console.log(`[Telemetry] Initialized with ${TELEMETRY_CONFIG.sampleRate * 100}% sampling rate`);
+
+  } catch (error) {
+    console.error('[Telemetry] Failed to initialize:', error);
+  }
+}
+
+// Create custom span for tracking specific operations
+export function startSpan(name, options = {}) {
+  if (!tracer) return null;
+
+  const span = tracer.startSpan(name, {
+    ...options,
+    attributes: {
+      'span.kind': 'internal',
+      'portal.type': 'performers',
+      ...options.attributes
+    }
+  });
+
+  debugLog(`Started span: ${name}`, options.attributes);
+  return span;
+}
+
+// End a span and set its status
+export function endSpan(span, status = { code: 0 }) {
+  if (!span) return;
+
+  span.setStatus(status);
+  span.end();
+  debugLog(`Ended span: ${span.name}`, status);
+}
+
+// Track page views (for SPAs)
+export function trackPageView(pagePath, pageTitle) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan('page_view', {
+    attributes: {
+      'page.path': pagePath,
+      'page.title': pageTitle || document.title,
+      'page.url': window.location.href,
+      'page.referrer': document.referrer,
+      'portal.type': 'performers'
+    }
+  });
+
+  span.end();
+  debugLog(`Tracked page view: ${pagePath}`);
+}
+
+// Track custom events
+export function trackEvent(eventName, attributes = {}) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan(`event.${eventName}`, {
+    attributes: {
+      'event.name': eventName,
+      'event.timestamp': new Date().toISOString(),
+      'portal.type': 'performers',
+      ...attributes
+    }
+  });
+
+  span.end();
+  debugLog(`Tracked event: ${eventName}`, attributes);
+}
+
+// Track performer-specific actions
+export function trackPerformerAction(action, metadata = {}) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan(`performer.${action}`, {
+    attributes: {
+      'performer.action': action,
+      'performer.metadata': JSON.stringify(metadata),
+      'portal.type': 'performers',
+      'page.url': window.location.href,
+      'timestamp': new Date().toISOString()
+    }
+  });
+
+  span.end();
+  debugLog(`Tracked performer action: ${action}`, metadata);
+}
+
+// Track errors
+export function trackError(error, context = {}) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan('error', {
+    attributes: {
+      'error.message': error.message || String(error),
+      'error.stack': error.stack,
+      'error.type': error.name || 'Error',
+      'error.context': JSON.stringify(context),
+      'page.url': window.location.href,
+      'portal.type': 'performers'
+    }
+  });
+
+  span.setStatus({ code: 2, message: error.message });
+  span.recordException(error);
+  span.end();
+
+  debugLog(`Tracked error: ${error.message}`, context);
+}
+
+// Track API calls with custom attributes
+export function trackAPICall(method, endpoint, status, duration, attributes = {}) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan('api_call', {
+    attributes: {
+      'http.method': method,
+      'http.url': endpoint,
+      'http.status_code': status,
+      'http.duration_ms': duration,
+      'portal.type': 'performers',
+      ...attributes
+    }
+  });
+
+  span.setStatus({ code: status >= 400 ? 2 : 0 });
+  span.end();
+
+  debugLog(`Tracked API call: ${method} ${endpoint}`, { status, duration });
+}
+
+// Track user actions
+export function trackUserAction(action, metadata = {}) {
+  if (!tracer) return;
+
+  const span = tracer.startSpan(`user.${action}`, {
+    attributes: {
+      'user.action': action,
+      'user.metadata': JSON.stringify(metadata),
+      'portal.type': 'performers',
+      'page.url': window.location.href,
+      'timestamp': new Date().toISOString()
+    }
+  });
+
+  span.end();
+  debugLog(`Tracked user action: ${action}`, metadata);
+}
+
+// Shutdown telemetry gracefully
+export async function shutdownTelemetry() {
+  if (tracerProvider) {
+    try {
+      await tracerProvider.shutdown();
+      console.log('[Telemetry] Shutdown complete');
+    } catch (error) {
+      console.error('[Telemetry] Shutdown error:', error);
+    }
+  }
+}
+
+// Connect client spans with SSR spans using trace context
+function connectWithSSRTrace() {
+  // Check if we have trace context from SSR
+  const ssrTraceContext = window.__TRACE_CONTEXT__;
+  if (ssrTraceContext && tracer) {
+    // Create a span linked to the SSR span
+    const span = tracer.startSpan('client.performer.init', {
+      attributes: {
+        'span.kind': 'client',
+        'client.type': 'browser',
+        'portal.type': 'performers',
+        'ssr.trace_id': ssrTraceContext.traceId,
+        'ssr.span_id': ssrTraceContext.spanId
+      },
+      links: [{
+        context: {
+          traceId: ssrTraceContext.traceId,
+          spanId: ssrTraceContext.spanId,
+          traceFlags: ssrTraceContext.traceFlags || 0
+        }
+      }]
+    });
+
+    span.end();
+    debugLog('Connected to SSR trace', ssrTraceContext);
+  }
+}
+
+// Auto-initialize on module load if in browser environment
+if (typeof window !== 'undefined') {
+  // Initialize telemetry when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => {
+      initTelemetry();
+      connectWithSSRTrace();
+    });
+  } else {
+    initTelemetry();
+    connectWithSSRTrace();
+  }
+
+  // Cleanup on page unload
+  window.addEventListener('beforeunload', () => {
+    shutdownTelemetry();
+  });
+}

package/dist/telemetry.server.d.ts

@@ -0,0 +1,11 @@
+export function initServerTelemetry(): void;
+export function createSSRSpan(name: any, request: any, attributes?: {}): import("@opentelemetry/api").Span;
+export function trackPerformerSSRDataLoad(loadFunction: any, context: any): (event: any) => Promise<any>;
+export function extractTraceContext(request: any): import("@opentelemetry/api").Context;
+export function injectTraceContext(response: any, span: any): any;
+export function shutdownServerTelemetry(): Promise<void>;
+export namespace performersPortalTelemetry {
+    function wrapLoad(loadFn: any, context: any): (event: any) => Promise<any>;
+    function wrapAction(actionFn: any, actionName: any): (event: any) => Promise<any>;
+}
+//# sourceMappingURL=telemetry.server.d.ts.map

package/dist/telemetry.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.server.d.ts","sourceRoot":"","sources":["../src/lib/telemetry.server.js"],"names":[],"mappings":"AAyBA,4CAqDC;AAGD,2GAkBC;AAGD,6EACgB,UAAK,kBA6BpB;AAGD,wFASC;AAGD,kEAiBC;AAGD,yDASC;;IAKW,2EAA+D;IAG7D,sDACI,UAAK,kBAmBpB"}