@grafana/faro-core 1.0.2 → 1.0.4

package/dist/spec/core/src/utils/promiseBuffer.test.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var testUtils_1 = require("../testUtils");
+var promiseBuffer_1 = require("./promiseBuffer");
+function defer(fn) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve) {
+                    setImmediate(function () {
+                        fn();
+                        resolve();
+                    });
+                })];
+        });
+    });
+}
+describe('PromiseBuffer', function () {
+    it('add() new promise that resolves when task is completed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var buf, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    buf = (0, promiseBuffer_1.createPromiseBuffer)({ size: 2, concurrency: 2 });
+                    _a = expect;
+                    return [4 /*yield*/, buf.add(function () { return Promise.resolve('hi'); })];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual('hi');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('executes tasks concurrently, limited to concurrency setting', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var promises, buf, addTask;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    promises = [];
+                    buf = (0, promiseBuffer_1.createPromiseBuffer)({
+                        size: 10,
+                        concurrency: 2,
+                    });
+                    addTask = function (id) {
+                        return buf.add(function () {
+                            var prom = (0, testUtils_1.createTestPromise)(id);
+                            promises.push(prom);
+                            return prom.promise;
+                        });
+                    };
+                    addTask(1);
+                    addTask(2);
+                    addTask(3);
+                    // 1 & 2 have started to execute. 3d is not started
+                    expect(promises).toHaveLength(2);
+                    expect((_a = promises[0]) === null || _a === void 0 ? void 0 : _a.id).toEqual(1);
+                    expect((_b = promises[1]) === null || _b === void 0 ? void 0 : _b.id).toEqual(2);
+                    // resolve first two
+                    (_c = promises[0]) === null || _c === void 0 ? void 0 : _c.resolve();
+                    (_d = promises[1]) === null || _d === void 0 ? void 0 : _d.resolve();
+                    return [4 /*yield*/, defer(function () {
+                            var _a, _b;
+                            // 3 has started to be executed
+                            expect(promises).toHaveLength(3);
+                            expect((_a = promises[2]) === null || _a === void 0 ? void 0 : _a.id).toEqual(3);
+                            (_b = promises[2]) === null || _b === void 0 ? void 0 : _b.resolve();
+                        })];
+                case 1:
+                    _e.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('rejects tasks that exceed buffer size', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var promises, buf, addTask;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    promises = [];
+                    buf = (0, promiseBuffer_1.createPromiseBuffer)({
+                        size: 3,
+                        concurrency: 2,
+                    });
+                    addTask = function (id) {
+                        return buf.add(function () {
+                            var prom = (0, testUtils_1.createTestPromise)(id);
+                            promises.push(prom);
+                            return prom.promise;
+                        });
+                    };
+                    // adding 3 tasks works, 2 of them begin executing
+                    addTask(1);
+                    addTask(2);
+                    addTask(3);
+                    expect(promises).toHaveLength(2);
+                    // adding 4th task fails
+                    expect(function () { return addTask(4); }).toThrow('Task buffer full');
+                    // finishing a task allows new tasks to be added again
+                    (_a = promises[0]) === null || _a === void 0 ? void 0 : _a.resolve();
+                    return [4 /*yield*/, defer(function () {
+                            addTask(4);
+                        })];
+                case 1:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=promiseBuffer.test.js.map

package/dist/spec/core/src/utils/promiseBuffer.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseBuffer.test.js","sourceRoot":"","sources":["../../../../../src/utils/promiseBuffer.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { createTestPromise, TestPromise } from '../testUtils';\n\nimport { createPromiseBuffer } from './promiseBuffer';\n\nasync function defer(fn: () => void) {\n  return new Promise<void>((resolve) => {\n    setImmediate(() => {\n      fn();\n      resolve();\n    });\n  });\n}\n\ndescribe('PromiseBuffer', () => {\n  it('add() new promise that resolves when task is completed', async () => {\n    const buf = createPromiseBuffer({ size: 2, concurrency: 2 });\n    expect(await buf.add(() => Promise.resolve('hi'))).toEqual('hi');\n  });\n\n  it('executes tasks concurrently, limited to concurrency setting', async () => {\n    const promises: Array<TestPromise<void>> = [];\n    const buf = createPromiseBuffer({\n      size: 10,\n      concurrency: 2,\n    });\n\n    const addTask = (id: number) => {\n      return buf.add(() => {\n        const prom = createTestPromise<void>(id);\n        promises.push(prom);\n        return prom.promise;\n      });\n    };\n\n    addTask(1);\n    addTask(2);\n    addTask(3);\n\n    // 1 & 2 have started to execute. 3d is not started\n    expect(promises).toHaveLength(2);\n    expect(promises[0]?.id).toEqual(1);\n    expect(promises[1]?.id).toEqual(2);\n\n    // resolve first two\n    promises[0]?.resolve();\n    promises[1]?.resolve();\n\n    await defer(() => {\n      // 3 has started to be executed\n      expect(promises).toHaveLength(3);\n      expect(promises[2]?.id).toEqual(3);\n      promises[2]?.resolve();\n    });\n  });\n\n  it('rejects tasks that exceed buffer size', async () => {\n    const promises: Array<TestPromise<void>> = [];\n    const buf = createPromiseBuffer({\n      size: 3,\n      concurrency: 2,\n    });\n\n    const addTask = (id: number) => {\n      return buf.add(() => {\n        const prom = createTestPromise<void>(id);\n        promises.push(prom);\n        return prom.promise;\n      });\n    };\n\n    // adding 3 tasks works, 2 of them begin executing\n    addTask(1);\n    addTask(2);\n    addTask(3);\n    expect(promises).toHaveLength(2);\n    // adding 4th task fails\n    expect(() => addTask(4)).toThrow('Task buffer full');\n\n    // finishing a task allows new tasks to be added again\n    promises[0]?.resolve();\n\n    await defer(() => {\n      addTask(4);\n    });\n  });\n});\n"]}

package/dist/spec/core/src/utils/shortId.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genShortID = void 0;
+var alphabet = 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789';
+function genShortID(length) {
+    if (length === void 0) { length = 10; }
+    return Array.from(Array(length))
+        .map(function () { return alphabet[Math.floor(Math.random() * alphabet.length)]; })
+        .join('');
+}
+exports.genShortID = genShortID;
+//# sourceMappingURL=shortId.js.map

package/dist/spec/core/src/utils/shortId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortId.js","sourceRoot":"","sources":["../../../../../src/utils/shortId.ts"],"names":[],"mappings":";;;AAAA,IAAM,QAAQ,GAAG,6DAA6D,CAAC;AAE/E,SAAgB,UAAU,CAAC,MAAW;IAAX,uBAAA,EAAA,WAAW;IACpC,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;SAC7B,GAAG,CAAC,cAAM,OAAA,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAE,EAAtD,CAAsD,CAAC;SACjE,IAAI,CAAC,EAAE,CAAC,CAAC;AACd,CAAC;AAJD,gCAIC","sourcesContent":["const alphabet = 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789';\n\nexport function genShortID(length = 10): string {\n  return Array.from(Array(length))\n    .map(() => alphabet[Math.floor(Math.random() * alphabet.length)]!)\n    .join('');\n}\n"]}

package/dist/spec/core/src/version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// auto-generated by bin/genVersion.ts
+exports.VERSION = '1.0.4';
+//# sourceMappingURL=version.js.map

package/dist/spec/core/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../../src/version.ts"],"names":[],"mappings":";;;AAAA,sCAAsC;AACzB,QAAA,OAAO,GAAG,OAAO,CAAC","sourcesContent":["// auto-generated by bin/genVersion.ts\nexport const VERSION = '1.0.4';\n"]}

package/dist/types/core/src/api/events/index.d.ts

@@ -0,0 +1,2 @@
+export type { EventAttributes, EventEvent, EventsAPI } from './types';
+export { initializeEventsAPI } from './initialize';

package/dist/types/core/src/api/events/initialize.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { TracesAPI } from '../traces';
+import type { EventsAPI } from './types';
+export declare function initializeEventsAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports, tracesApi: TracesAPI): EventsAPI;

package/dist/types/core/src/api/events/initialize.test.d.ts

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

package/dist/types/core/src/api/events/types.d.ts

@@ -0,0 +1,15 @@
+import type { TraceContext } from '../traces';
+export type EventAttributes = Record<string, string>;
+export interface EventEvent {
+    name: string;
+    timestamp: string;
+    domain?: string;
+    attributes?: EventAttributes;
+    trace?: TraceContext;
+}
+export interface PushEventOptions {
+    skipDedupe?: boolean;
+}
+export interface EventsAPI {
+    pushEvent: (name: string, attributes?: EventAttributes, domain?: string, options?: PushEventOptions) => void;
+}

package/dist/types/core/src/api/exceptions/const.d.ts

@@ -0,0 +1 @@
+export declare const defaultExceptionType = "Error";

package/dist/types/core/src/api/exceptions/index.d.ts

@@ -0,0 +1,3 @@
+export { defaultExceptionType } from './const';
+export { initializeExceptionsAPI } from './initialize';
+export type { ExceptionEvent, ExceptionStackFrame, ExceptionsAPI, ExtendedError, PushErrorOptions, Stacktrace, StacktraceParser, } from './types';

package/dist/types/core/src/api/exceptions/initialize.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import type { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { TracesAPI } from '../traces';
+import type { ExceptionsAPI } from './types';
+export declare function initializeExceptionsAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports, tracesApi: TracesAPI): ExceptionsAPI;

package/dist/types/core/src/api/exceptions/initialize.test.d.ts

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

package/dist/types/core/src/api/exceptions/types.d.ts

@@ -0,0 +1,32 @@
+import type { TraceContext } from '../traces';
+export type StacktraceParser = (err: ExtendedError) => Stacktrace;
+export interface ExceptionStackFrame {
+    filename: string;
+    function: string;
+    colno?: number;
+    lineno?: number;
+}
+export interface ExtendedError extends Error {
+    columnNumber?: number;
+    stacktrace?: Error['stack'];
+}
+export interface Stacktrace {
+    frames: ExceptionStackFrame[];
+}
+export interface ExceptionEvent {
+    timestamp: string;
+    type: string;
+    value: string;
+    stacktrace?: Stacktrace;
+    trace?: TraceContext;
+}
+export interface PushErrorOptions {
+    skipDedupe?: boolean;
+    stackFrames?: ExceptionStackFrame[];
+    type?: string;
+}
+export interface ExceptionsAPI {
+    changeStacktraceParser: (stacktraceParser: StacktraceParser) => void;
+    getStacktraceParser: () => StacktraceParser | undefined;
+    pushError: (value: Error, options?: PushErrorOptions) => void;
+}

package/dist/types/core/src/api/index.d.ts

@@ -0,0 +1,9 @@
+export { initializeAPI } from './initialize';
+export type { API, APIEvent } from './types';
+export type { EventAttributes, EventEvent, EventsAPI } from './events';
+export { defaultExceptionType } from './exceptions';
+export type { ExceptionEvent, ExceptionStackFrame, ExceptionsAPI, ExtendedError, PushErrorOptions, Stacktrace, StacktraceParser, } from './exceptions';
+export type { LogContext, LogEvent, LogsAPI, PushLogOptions } from './logs';
+export type { MeasurementEvent, MeasurementsAPI, PushMeasurementOptions } from './measurements';
+export type { MetaAPI } from './meta';
+export type { OTELApi, TraceContext, TraceEvent, TracesAPI } from './traces';

package/dist/types/core/src/api/initialize.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '../config';
+import type { InternalLogger } from '../internalLogger';
+import type { Metas } from '../metas';
+import type { Transports } from '../transports';
+import type { UnpatchedConsole } from '../unpatchedConsole';
+import type { API } from './types';
+export declare function initializeAPI(unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports): API;

package/dist/types/core/src/api/logs/index.d.ts

@@ -0,0 +1,2 @@
+export { initializeLogsAPI } from './initialize';
+export type { LogContext, LogEvent, LogsAPI, PushLogOptions } from './types';

package/dist/types/core/src/api/logs/initialize.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import type { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { TracesAPI } from '../traces';
+import type { LogsAPI } from './types';
+export declare function initializeLogsAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports, tracesApi: TracesAPI): LogsAPI;

package/dist/types/core/src/api/logs/initialize.test.d.ts

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

package/dist/types/core/src/api/logs/types.d.ts

@@ -0,0 +1,18 @@
+import type { BaseObject, LogLevel } from '../../utils';
+import type { TraceContext } from '../traces';
+export type LogContext = BaseObject;
+export interface LogEvent {
+    context: LogContext;
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    trace?: TraceContext;
+}
+export interface PushLogOptions {
+    context?: LogContext;
+    level?: LogLevel;
+    skipDedupe?: boolean;
+}
+export interface LogsAPI {
+    pushLog: (args: unknown[], options?: PushLogOptions) => void;
+}

package/dist/types/core/src/api/measurements/index.d.ts

@@ -0,0 +1,2 @@
+export { initializeMeasurementsAPI } from './initialize';
+export type { MeasurementEvent, MeasurementsAPI, PushMeasurementOptions } from './types';

package/dist/types/core/src/api/measurements/initialize.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import type { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { TracesAPI } from '../traces';
+import type { MeasurementsAPI } from './types';
+export declare function initializeMeasurementsAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports, tracesApi: TracesAPI): MeasurementsAPI;

package/dist/types/core/src/api/measurements/initialize.test.d.ts

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

package/dist/types/core/src/api/measurements/types.d.ts

@@ -0,0 +1,17 @@
+import type { TraceContext } from '../traces';
+export interface MeasurementEvent<V extends {
+    [label: string]: number;
+} = {
+    [label: string]: number;
+}> {
+    type: string;
+    values: V;
+    timestamp: string;
+    trace?: TraceContext;
+}
+export interface PushMeasurementOptions {
+    skipDedupe?: boolean;
+}
+export interface MeasurementsAPI {
+    pushMeasurement: (payload: Omit<MeasurementEvent, 'timestamp'> & Partial<Pick<MeasurementEvent, 'timestamp'>>, options?: PushMeasurementOptions) => void;
+}

package/dist/types/core/src/api/meta/index.d.ts

@@ -0,0 +1,2 @@
+export { initializeMetaAPI } from './initialize';
+export type { MetaAPI } from './types';

package/dist/types/core/src/api/meta/initialize.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import type { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { MetaAPI } from './types';
+export declare function initializeMetaAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, _config: Config, metas: Metas, _transports: Transports): MetaAPI;

package/dist/types/core/src/api/meta/types.d.ts

@@ -0,0 +1,10 @@
+import type { MetaSession, MetaUser, MetaView } from '../../metas';
+export interface MetaAPI {
+    setUser: (user?: MetaUser | undefined) => void;
+    resetUser: () => void;
+    setSession: (session?: MetaSession | undefined) => void;
+    resetSession: () => void;
+    getSession: () => MetaSession | undefined;
+    setView: (view?: MetaView | undefined) => void;
+    getView: () => MetaView | undefined;
+}

package/dist/types/core/src/api/traces/index.d.ts

@@ -0,0 +1,2 @@
+export { initializeTracesAPI } from './initialize';
+export type { OTELApi, TraceContext, TraceEvent, TracesAPI } from './types';

package/dist/types/core/src/api/traces/initialize.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '../../config';
+import type { InternalLogger } from '../../internalLogger';
+import type { Metas } from '../../metas';
+import { Transports } from '../../transports';
+import type { UnpatchedConsole } from '../../unpatchedConsole';
+import type { TracesAPI } from './types';
+export declare function initializeTracesAPI(_unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, _config: Config, metas: Metas, transports: Transports): TracesAPI;

package/dist/types/core/src/api/traces/types.d.ts

@@ -0,0 +1,20 @@
+import type { ContextAPI as OTELContextAPI, TraceAPI as OTELTraceAPI } from '@opentelemetry/api';
+import type { IResourceSpans } from '@opentelemetry/otlp-transformer';
+export interface TraceEvent {
+    resourceSpans?: IResourceSpans[];
+}
+export interface OTELApi {
+    trace: OTELTraceAPI;
+    context: OTELContextAPI;
+}
+export interface TracesAPI {
+    getOTEL: () => OTELApi | undefined;
+    getTraceContext: () => TraceContext | undefined;
+    initOTEL: (trace: OTELTraceAPI, context: OTELContextAPI) => void;
+    isOTELInitialized: () => boolean;
+    pushTraces: (traces: TraceEvent) => void;
+}
+export interface TraceContext {
+    trace_id: string;
+    span_id: string;
+}

package/dist/types/core/src/api/types.d.ts

@@ -0,0 +1,8 @@
+import type { EventEvent, EventsAPI } from './events';
+import type { ExceptionEvent, ExceptionsAPI } from './exceptions';
+import type { LogEvent, LogsAPI } from './logs';
+import type { MeasurementEvent, MeasurementsAPI } from './measurements';
+import type { MetaAPI } from './meta';
+import type { TraceEvent, TracesAPI } from './traces';
+export type APIEvent = LogEvent | ExceptionEvent | MeasurementEvent | TraceEvent | EventEvent;
+export type API = LogsAPI & ExceptionsAPI & MeasurementsAPI & TracesAPI & MetaAPI & EventsAPI;

package/dist/types/core/src/config/const.d.ts

@@ -0,0 +1 @@
+export declare const defaultGlobalObjectKey = "faro";

package/dist/types/core/src/config/index.d.ts

@@ -0,0 +1,2 @@
+export { defaultGlobalObjectKey } from './const';
+export type { Config, Patterns } from './types';

package/dist/types/core/src/config/types.d.ts

@@ -0,0 +1,27 @@
+import type { APIEvent, StacktraceParser } from '../api';
+import type { Instrumentation } from '../instrumentations';
+import type { InternalLoggerLevel } from '../internalLogger';
+import type { MetaApp, MetaItem, MetaSession, MetaUser, MetaView } from '../metas';
+import type { BeforeSendHook, Transport } from '../transports';
+import type { UnpatchedConsole } from '../unpatchedConsole';
+export interface Config<P = APIEvent> {
+    app: MetaApp;
+    dedupe: boolean;
+    globalObjectKey: string;
+    isolate: boolean;
+    instrumentations: Instrumentation[];
+    internalLoggerLevel: InternalLoggerLevel;
+    metas: MetaItem[];
+    parseStacktrace: StacktraceParser;
+    paused: boolean;
+    preventGlobalExposure: boolean;
+    transports: Transport[];
+    unpatchedConsole: UnpatchedConsole;
+    beforeSend?: BeforeSendHook<P>;
+    ignoreErrors?: Patterns;
+    session?: MetaSession;
+    user?: MetaUser;
+    view?: MetaView;
+    eventDomain?: string;
+}
+export type Patterns = Array<string | RegExp>;

package/dist/types/core/src/extensions/baseExtension.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from '../config';
+import type { Metas } from '../metas';
+import type { Extension } from './types';
+export declare abstract class BaseExtension implements Extension {
+    abstract readonly name: string;
+    abstract readonly version: string;
+    unpatchedConsole: Console;
+    internalLogger: import("../internalLogger").InternalLogger;
+    config: Config<import("..").APIEvent>;
+    metas: Metas;
+    logDebug(...args: unknown[]): void;
+    logInfo(...args: unknown[]): void;
+    logWarn(...args: unknown[]): void;
+    logError(...args: unknown[]): void;
+}

package/dist/types/core/src/extensions/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseExtension } from './baseExtension';
+export type { Extension } from './types';

package/dist/types/core/src/extensions/types.d.ts

@@ -0,0 +1,16 @@
+import type { Config } from '../config';
+import type { InternalLogger } from '../internalLogger';
+import type { Metas } from '../metas';
+import type { UnpatchedConsole } from '../unpatchedConsole';
+export interface Extension {
+    readonly name: string;
+    readonly version: string;
+    internalLogger: InternalLogger;
+    unpatchedConsole: UnpatchedConsole;
+    config: Config;
+    metas: Metas;
+    logDebug(...args: unknown[]): void;
+    logInfo(...args: unknown[]): void;
+    logWarn(...args: unknown[]): void;
+    logError(...args: unknown[]): void;
+}

package/dist/types/core/src/faro.test.d.ts

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

package/dist/types/core/src/globalObject/globalObject.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type { Faro, internalGlobalObjectKey } from '../sdk';
+export type GlobalObject<T = typeof window | typeof global> = T & {
+    [label: string]: Faro;
+    [internalGlobalObjectKey]: Faro;
+};
+export declare const globalObject: GlobalObject<typeof globalThis | (Window & typeof globalThis)>;

package/dist/types/core/src/globalObject/index.d.ts

@@ -0,0 +1,2 @@
+export { globalObject } from './globalObject';
+export type { GlobalObject } from './globalObject';

package/dist/types/core/src/index.d.ts

@@ -0,0 +1,24 @@
+export { defaultExceptionType } from './api';
+export type { API, APIEvent, EventAttributes, EventEvent, EventsAPI, ExceptionEvent, ExceptionStackFrame, ExceptionsAPI, ExtendedError, LogContext, LogEvent, LogsAPI, MeasurementEvent, MeasurementsAPI, MetaAPI, OTELApi, PushErrorOptions, PushLogOptions, PushMeasurementOptions, Stacktrace, StacktraceParser, TraceContext, TraceEvent, TracesAPI, } from './api';
+export { BaseExtension } from './extensions';
+export type { Extension } from './extensions';
+export { globalObject } from './globalObject';
+export type { GlobalObject } from './globalObject';
+export { initializeFaro } from './initialize';
+export { defaultGlobalObjectKey } from './config';
+export type { Config, Patterns } from './config';
+export { BaseInstrumentation } from './instrumentations';
+export type { Instrumentation, Instrumentations } from './instrumentations';
+export { createInternalLogger, defaultInternalLoggerLevel, InternalLoggerLevel } from './internalLogger';
+export type { InternalLogger } from './internalLogger';
+export type { Meta, MetaApp, MetaAttributes, MetaBrowser, MetaGetter, MetaItem, MetaPage, Metas, MetaSDK, MetaSDKIntegration, MetaSession, MetaUser, MetaView, } from './metas';
+export { faro, getInternalFaroFromGlobalObject, internalGlobalObjectKey, isInternalFaroOnGlobalObject, setInternalFaroOnGlobalObject, } from './sdk';
+export type { Faro } from './sdk';
+export { Conventions } from './semantic';
+export { BaseTransport, getTransportBody, TransportItemType, transportItemTypeToBodyKey } from './transports';
+export type { BeforeSendHook, Transport, TransportBody, TransportItem, TransportItemPayload, Transports, } from './transports';
+export { defaultUnpatchedConsole } from './unpatchedConsole';
+export type { UnpatchedConsole } from './unpatchedConsole';
+export { allLogLevels, createPromiseBuffer, deepEqual, defaultLogLevel, genShortID, getCurrentTimestamp, isArray, isBoolean, isDomError, isDomException, isElement, isElementDefined, isError, isErrorDefined, isErrorEvent, isEvent, isEventDefined, isFunction, isInstanceOf, isInt, isMap, isMapDefined, isNull, isNumber, isObject, isPrimitive, isRegExp, isString, isSymbol, isSyntheticEvent, isThenable, isToString, isTypeof, isUndefined, LogLevel, noop, } from './utils';
+export type { BaseObject, BaseObjectKey, BaseObjectPrimitiveValue, BaseObjectValue, BufferItem, PromiseBuffer, PromiseBufferOptions, PromiseProducer, } from './utils';
+export { VERSION } from './version';

package/dist/types/core/src/initialize.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from './config';
+import type { Faro } from './sdk';
+export declare function initializeFaro(config: Config): Faro;

package/dist/types/core/src/instrumentations/base.d.ts

@@ -0,0 +1,9 @@
+import type { API } from '../api';
+import { BaseExtension } from '../extensions';
+import type { Transports } from '../transports';
+import type { Instrumentation } from './types';
+export declare abstract class BaseInstrumentation extends BaseExtension implements Instrumentation {
+    api: API;
+    transports: Transports;
+    abstract initialize(): void;
+}

package/dist/types/core/src/instrumentations/index.d.ts

@@ -0,0 +1,4 @@
+export { BaseInstrumentation } from './base';
+export { initializeInstrumentations } from './initialize';
+export { registerInitialInstrumentations } from './registerInitial';
+export type { Instrumentation, Instrumentations } from './types';

package/dist/types/core/src/instrumentations/initialize.d.ts

@@ -0,0 +1,8 @@
+import type { API } from '../api';
+import type { Config } from '../config';
+import type { InternalLogger } from '../internalLogger';
+import type { Metas } from '../metas';
+import type { Transports } from '../transports';
+import type { UnpatchedConsole } from '../unpatchedConsole';
+import type { Instrumentations } from './types';
+export declare function initializeInstrumentations(unpatchedConsole: UnpatchedConsole, internalLogger: InternalLogger, config: Config, metas: Metas, transports: Transports, api: API): Instrumentations;

package/dist/types/core/src/instrumentations/registerInitial.d.ts

@@ -0,0 +1,2 @@
+import type { Faro } from '../sdk';
+export declare function registerInitialInstrumentations(faro: Faro): void;

package/dist/types/core/src/instrumentations/types.d.ts

@@ -0,0 +1,14 @@
+import type { API } from '../api';
+import type { Extension } from '../extensions';
+import type { Transports } from '../transports';
+export interface Instrumentation extends Extension {
+    api: API;
+    transports: Transports;
+    initialize: VoidFunction;
+    destroy?: VoidFunction;
+}
+export interface Instrumentations {
+    add: (...instrumentations: Instrumentation[]) => void;
+    instrumentations: Instrumentation[];
+    remove: (...instrumentations: Instrumentation[]) => void;
+}

package/dist/types/core/src/internalLogger/const.d.ts

@@ -0,0 +1,11 @@
+import type { InternalLogger } from './types';
+export declare enum InternalLoggerLevel {
+    OFF = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    VERBOSE = 4
+}
+export declare const defaultInternalLoggerPrefix = "Faro";
+export declare const defaultInternalLogger: InternalLogger;
+export declare const defaultInternalLoggerLevel = InternalLoggerLevel.ERROR;