@flareapp/js 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Spatie bvba <info@spatie.be>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# The JavaScript client for Flare to catch frontend errors
+
+Read the JavaScript error tracking section in [the Flare documentation](https://flareapp.io/docs/javascript-error-tracking/installation) for more information.
+
+React plugin: https://www.npmjs.com/package/@flareapp/react
+
+Vue plugin: https://www.npmjs.com/package/@flareapp/vue
+
+Webpack plugin: https://www.npmjs.com/package/@flareapp/flare-webpack-plugin-sourcemap

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@flareapp/js",
+    "version": "1.0.0-beta.0",
+    "description": "JavaScript client for flareapp.io",
+    "homepage": "https://flareapp.io",
+    "bugs": {
+        "url": "https://github.com/facade/flare-client-js/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/facade/flare-client-js.git"
+    },
+    "license": "MIT",
+    "author": "adriaan@spatie.be",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts --env.FLARE_JS_CLIENT_VERSION=\\\"$(node -p \"require('./package.json').version\")\\\" --clean",
+        "dev": "npm run build",
+        "test": "vitest run",
+        "typescript": "tsc"
+    },
+    "dependencies": {
+        "error-stack-parser": "^2.0.2"
+    },
+    "devDependencies": {
+        "tsup": "^8.0.1",
+        "typescript": "^5.3.3",
+        "vitest": "^1.0.4"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/FlareClient.ts

@@ -0,0 +1,285 @@
+import { assert, now, flatJsonStringify } from './util';
+import { collectContext } from './context';
+import { createStackTrace } from './stacktrace';
+import build from './build';
+import getSolutions from './solutions';
+import { Flare } from './types';
+
+export default class FlareClient {
+    public version: string = build.clientVersion;
+
+    public config: Flare.Config = {
+        key: '',
+        reportingUrl: 'https://flareapp.io/api/reports',
+        maxGlowsPerReport: 30,
+        maxReportsPerMinute: 500,
+    };
+
+    private glows: Array<Flare.Glow> = [];
+
+    private context: Flare.Context = { context: {} };
+
+    public beforeEvaluate: Flare.BeforeEvaluate = (error) => error;
+
+    public beforeSubmit: Flare.BeforeSubmit = (report) => report;
+
+    private reportedErrorsTimestamps: Array<number> = [];
+
+    private solutionProviders: Array<Flare.SolutionProvider> = [];
+
+    private sourcemapVersion: string = build.sourcemapVersion;
+
+    public debug: boolean = false;
+
+    public stage: string | undefined = undefined;
+
+    public light(key: string = build.flareJsKey, debug = false): FlareClient {
+        this.debug = debug;
+
+        if (
+            !assert(
+                key && typeof key === 'string',
+                'An empty or incorrect Flare key was passed, errors will not be reported.',
+                this.debug,
+            ) ||
+            !assert(
+                Promise,
+                'ES6 promises are not supported in this environment, errors will not be reported.',
+                this.debug,
+            )
+        ) {
+            return this;
+        }
+
+        this.config.key = key;
+
+        return this;
+    }
+
+    public glow(
+        name: string,
+        level: Flare.MessageLevel = 'info',
+        metaData: Array<object> = [],
+    ): FlareClient {
+        const time = now();
+
+        this.glows.push({
+            name,
+            message_level: level,
+            meta_data: metaData,
+            time,
+            microtime: time,
+        });
+
+        if (this.glows.length > this.config.maxGlowsPerReport) {
+            this.glows = this.glows.slice(
+                this.glows.length - this.config.maxGlowsPerReport,
+            );
+        }
+
+        return this;
+    }
+
+    public addContext(name: string, value: any): FlareClient {
+        this.context.context[name] = value;
+
+        return this;
+    }
+
+    public addContextGroup(groupName: string, value: object): FlareClient {
+        this.context[groupName] = value;
+
+        return this;
+    }
+
+    public registerSolutionProvider(
+        provider: Flare.SolutionProvider,
+    ): FlareClient {
+        if (
+            !assert(
+                'canSolve' in provider,
+                'A solution provider without a [canSolve] property was added.',
+                this.debug,
+            ) ||
+            !assert(
+                'getSolutions' in provider,
+                'A solution provider without a [getSolutions] property was added.',
+                this.debug,
+            )
+        ) {
+            return this;
+        }
+
+        this.solutionProviders.push(provider);
+
+        return this;
+    }
+
+    public reportMessage(
+        message: string,
+        context: Flare.Context = {},
+        exceptionClass: string = 'Log',
+    ): void {
+        const seenAt = now();
+
+        createStackTrace(Error()).then((stacktrace) => {
+            // The first item in the stacktrace is from this file, and irrelevant
+            stacktrace.shift();
+
+            const report: Flare.ErrorReport = {
+                notifier: `Flare JavaScript client v${build.clientVersion}`,
+                exception_class: exceptionClass,
+                seen_at: seenAt,
+                message: message,
+                language: 'javascript',
+                glows: this.glows,
+                context: collectContext({ ...context, ...this.context }),
+                stacktrace,
+                sourcemap_version_id: this.sourcemapVersion,
+                solutions: [],
+                stage: this.stage,
+            };
+
+            this.sendReport(report);
+        });
+    }
+
+    public report(
+        error: Error,
+        context: Flare.Context = {},
+        extraSolutionParameters: Flare.SolutionProviderExtraParameters = {},
+    ): void {
+        Promise.resolve(this.beforeEvaluate(error)).then(
+            (reportReadyForEvaluation) => {
+                if (!reportReadyForEvaluation) {
+                    return;
+                }
+
+                this.createReport(error, context, extraSolutionParameters).then(
+                    (report) => (report ? this.sendReport(report) : {}),
+                );
+            },
+        );
+    }
+
+    public createReport(
+        error: Error,
+        context: Flare.Context = {},
+        extraSolutionParameters: Flare.SolutionProviderExtraParameters = {},
+    ): Promise<Flare.ErrorReport | false> {
+        if (!assert(error, 'No error provided.', this.debug)) {
+            return Promise.resolve(false);
+        }
+
+        const seenAt = now();
+
+        return Promise.all([
+            getSolutions(
+                this.solutionProviders,
+                error,
+                extraSolutionParameters,
+            ),
+            createStackTrace(error),
+        ]).then((result) => {
+            const [solutions, stacktrace] = result;
+
+            assert(
+                stacktrace.length,
+                "Couldn't generate stacktrace of this error: " + error,
+                this.debug,
+            );
+
+            return {
+                notifier: `Flare JavaScript client v${build.clientVersion}`,
+                exception_class:
+                    error.constructor && error.constructor.name
+                        ? error.constructor.name
+                        : 'undefined',
+                seen_at: seenAt,
+                message: error.message,
+                language: 'javascript',
+                glows: this.glows,
+                context: collectContext({ ...context, ...this.context }),
+                stacktrace,
+                sourcemap_version_id: this.sourcemapVersion,
+                solutions,
+                stage: this.stage,
+            };
+        });
+    }
+
+    private sendReport(report: Flare.ErrorReport): void {
+        if (
+            !assert(
+                this.config.key,
+                'The client was not yet initialised with an API key. ' +
+                    "Run client.light('<flare-project-key>') when you initialise your app. " +
+                    "If you are running in dev mode and didn't run the light command on purpose, you can ignore this error.",
+                this.debug,
+            )
+        ) {
+            return;
+        }
+
+        if (this.maxReportsPerMinuteReached()) {
+            return;
+        }
+
+        Promise.resolve(this.beforeSubmit(report)).then(
+            (reportReadyForSubmit) => {
+                if (!reportReadyForSubmit) {
+                    return;
+                }
+
+                fetch(this.config.reportingUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Requested-With': 'XMLHttpRequest',
+                        'x-api-token': this.config.key,
+                    },
+                    body: flatJsonStringify({
+                        ...reportReadyForSubmit,
+                        key: this.config.key,
+                    }),
+                }).then(
+                    (response) => {
+                        if (response.status !== 204) {
+                            console.error(
+                                `Received response with status ${response.status} from Flare`,
+                            );
+                        }
+                    },
+                    (error) => console.error(error),
+                );
+
+                this.reportedErrorsTimestamps.push(Date.now());
+            },
+        );
+    }
+
+    private maxReportsPerMinuteReached(): boolean {
+        if (
+            this.reportedErrorsTimestamps.length >=
+            this.config.maxReportsPerMinute
+        ) {
+            const nErrorsBack =
+                this.reportedErrorsTimestamps[
+                    this.reportedErrorsTimestamps.length -
+                        this.config.maxReportsPerMinute
+                ];
+
+            if (nErrorsBack > Date.now() - 60 * 1000) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public test(): FlareClient {
+        this.report(new Error('The Flare client is set up correctly!'));
+
+        return this;
+    }
+}

package/src/browserClient/index.ts

@@ -0,0 +1,37 @@
+export default function catchWindowErrors() {
+    if (typeof window === 'undefined') {
+        return;
+    }
+
+    const flare = window.flare;
+
+    if (!window || !flare) {
+        return;
+    }
+
+    const originalOnerrorHandler = window.onerror;
+    const originalOnunhandledrejectionHandler = window.onunhandledrejection;
+
+    window.onerror = (_1, _2, _3, _4, error) => {
+        if (error) {
+            flare.report(error);
+        }
+
+        if (typeof originalOnerrorHandler === 'function') {
+            originalOnerrorHandler(_1, _2, _3, _4, error);
+        }
+    };
+
+    window.onunhandledrejection = (error: PromiseRejectionEvent) => {
+        if (error.reason instanceof Error) {
+            flare.report(error.reason);
+        }
+
+        // TODO: Maybe also send errors without stacktrace for unhandled rejections without an Error as reason? (could be a string, …)
+
+        if (typeof originalOnunhandledrejectionHandler === 'function') {
+            // @ts-ignore
+            originalOnunhandledrejectionHandler(error);
+        }
+    };
+}

package/src/build.ts

@@ -0,0 +1,16 @@
+declare const FLARE_JS_KEY: string | undefined;
+declare const FLARE_SOURCEMAP_VERSION: string | undefined;
+
+export default {
+    // Injected during build
+    clientVersion:
+        typeof process.env.FLARE_JS_CLIENT_VERSION === 'undefined'
+            ? '?'
+            : process.env.FLARE_JS_CLIENT_VERSION,
+    // Optionally injected by flare-vite-plugin-sourcemap-uploader
+    flareJsKey: typeof FLARE_JS_KEY === 'undefined' ? '' : FLARE_JS_KEY,
+    sourcemapVersion:
+        typeof FLARE_SOURCEMAP_VERSION === 'undefined'
+            ? ''
+            : FLARE_SOURCEMAP_VERSION,
+};

package/src/context/cookie.ts

@@ -0,0 +1,17 @@
+export default function cookie() {
+    if (!window.document.cookie) {
+        return {};
+    }
+
+    return {
+        cookies: window.document.cookie.split('; ').reduce(
+            (cookies, cookie) => {
+                const [cookieName, cookieValue] = cookie.split(/=/);
+                cookies[cookieName] = cookieValue;
+
+                return cookies;
+            },
+            {} as { [key: string]: string },
+        ),
+    };
+}

package/src/context/index.ts

@@ -0,0 +1,17 @@
+import cookie from './cookie';
+import request from './request';
+import requestData from './requestData';
+import { Flare } from '../types';
+
+export function collectContext(additionalContext: object): Flare.Context {
+    if (typeof window === 'undefined') {
+        return additionalContext;
+    }
+
+    return {
+        ...cookie(),
+        ...request(),
+        ...requestData(),
+        ...additionalContext,
+    };
+}

package/src/context/request.ts

@@ -0,0 +1,10 @@
+export default function request() {
+    return {
+        request: {
+            url: window.document.location.href,
+            useragent: window.navigator.userAgent,
+            referrer: window.document.referrer,
+            readyState: window.document.readyState,
+        },
+    };
+}

package/src/context/requestData.ts

@@ -0,0 +1,13 @@
+export default function requestData() {
+    if (!window.location.search) {
+        return {};
+    }
+
+    const queryString: { [key: string]: string } = {};
+
+    new URLSearchParams(window.location.search).forEach((value, key) => {
+        queryString[key] = value;
+    });
+
+    return { request_data: { queryString } };
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import FlareClient from './FlareClient';
+import catchWindowErrors from './browserClient';
+export { readLinesFromFile } from './stacktrace/fileReader';
+
+export const flare = new FlareClient();
+
+if (typeof window !== 'undefined' && window) {
+    window.flare = flare;
+}
+
+catchWindowErrors();

package/src/module.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+    flare: import('./FlareClient').default;
+}

package/src/solutions/index.ts

@@ -0,0 +1,44 @@
+import { flattenOnce } from '../util';
+import { Flare } from '../types';
+
+export default function getSolutions(
+    solutionProviders: Array<Flare.SolutionProvider>,
+    error: Error,
+    extraSolutionParameters: Flare.SolutionProviderExtraParameters = {},
+): Promise<Array<Flare.Solution>> {
+    return new Promise((resolve) => {
+        const canSolves = solutionProviders.reduce(
+            (canSolves, provider) => {
+                canSolves.push(
+                    Promise.resolve(
+                        provider.canSolve(error, extraSolutionParameters),
+                    ),
+                );
+
+                return canSolves;
+            },
+            [] as Array<Promise<boolean>>,
+        );
+
+        Promise.all(canSolves).then((resolvedCanSolves) => {
+            const solutionPromises: Array<Promise<Array<Flare.Solution>>> = [];
+
+            resolvedCanSolves.forEach((canSolve, i) => {
+                if (canSolve) {
+                    solutionPromises.push(
+                        Promise.resolve(
+                            solutionProviders[i].getSolutions(
+                                error,
+                                extraSolutionParameters,
+                            ),
+                        ),
+                    );
+                }
+            });
+
+            Promise.all(solutionPromises).then((solutions) => {
+                resolve(flattenOnce(solutions));
+            });
+        });
+    });
+}

package/src/stacktrace/fileReader.ts

@@ -0,0 +1,110 @@
+const cachedFiles: { [key: string]: string } = {};
+
+type CodeSnippet = {
+    [key: number]: string;
+};
+
+type ReaderResponse = {
+    codeSnippet: CodeSnippet;
+    trimmedColumnNumber: number | null;
+};
+
+export function getCodeSnippet(
+    url?: string,
+    lineNumber?: number,
+    columnNumber?: number,
+): Promise<ReaderResponse> {
+    return new Promise((resolve) => {
+        if (!url || !lineNumber) {
+            return resolve({
+                codeSnippet: {
+                    0: `Could not read from file: missing file URL or line number. URL: ${url} lineNumber: ${lineNumber}`,
+                },
+                trimmedColumnNumber: null,
+            });
+        }
+
+        readFile(url).then((fileText) => {
+            if (!fileText) {
+                return resolve({
+                    codeSnippet: {
+                        0: `Could not read from file: Error while opening file at URL ${url}`,
+                    },
+                    trimmedColumnNumber: null,
+                });
+            }
+
+            return resolve(
+                readLinesFromFile(fileText, lineNumber, columnNumber),
+            );
+        });
+    });
+}
+
+function readFile(url: string): Promise<string | null> {
+    if (cachedFiles[url]) {
+        return Promise.resolve(cachedFiles[url]);
+    }
+
+    return fetch(url)
+        .then((response) => {
+            if (response.status !== 200) {
+                return null;
+            }
+
+            return response.text();
+        })
+        .catch(() => null);
+}
+
+export function readLinesFromFile(
+    fileText: string,
+    lineNumber: number,
+    columnNumber?: number,
+    maxSnippetLineLength = 1000,
+    maxSnippetLines = 40,
+): ReaderResponse {
+    const codeSnippet: CodeSnippet = {};
+    let trimmedColumnNumber = null;
+
+    const lines = fileText.split('\n');
+
+    for (let i = -maxSnippetLines / 2; i <= maxSnippetLines / 2; i++) {
+        const currentLineIndex = lineNumber + i;
+
+        if (currentLineIndex >= 0 && lines[currentLineIndex]) {
+            const displayLine = currentLineIndex + 1; // the linenumber in a stacktrace is not zero-based like an array
+
+            if (lines[currentLineIndex].length > maxSnippetLineLength) {
+                if (
+                    columnNumber &&
+                    columnNumber + maxSnippetLineLength / 2 >
+                        maxSnippetLineLength
+                ) {
+                    codeSnippet[displayLine] = lines[currentLineIndex].substr(
+                        columnNumber - Math.round(maxSnippetLineLength / 2),
+                        maxSnippetLineLength,
+                    );
+
+                    if (displayLine === lineNumber) {
+                        trimmedColumnNumber = Math.round(
+                            maxSnippetLineLength / 2,
+                        );
+                    }
+
+                    continue;
+                }
+
+                codeSnippet[displayLine] =
+                    lines[currentLineIndex].substr(0, maxSnippetLineLength) +
+                    '…';
+
+                continue;
+            }
+
+            codeSnippet[displayLine] = lines[currentLineIndex];
+        }
+    }
+
+    return { codeSnippet, trimmedColumnNumber };
+}

package/src/stacktrace/index.ts

@@ -0,0 +1,71 @@
+import ErrorStackParser from 'error-stack-parser';
+import { getCodeSnippet } from './fileReader';
+import { Flare } from '../types';
+import { flare } from '..';
+import { assert } from '../util';
+
+export function createStackTrace(
+    error: Error,
+): Promise<Array<Flare.StackFrame>> {
+    return new Promise((resolve) => {
+        if (!hasStack(error)) {
+            assert(
+                false,
+                "Couldn't generate stacktrace of below error:",
+                flare.debug,
+            );
+
+            if (flare.debug) {
+                console.error(error);
+            }
+
+            return resolve([
+                {
+                    line_number: 0,
+                    column_number: 0,
+                    method: 'unknown',
+                    file: 'unknown',
+                    code_snippet: {
+                        0: 'Could not read from file: stacktrace missing',
+                    },
+                    trimmed_column_number: null,
+                    class: 'unknown',
+                },
+            ]);
+        }
+
+        Promise.all(
+            ErrorStackParser.parse(error).map((frame) => {
+                return new Promise<Flare.StackFrame>((resolve) => {
+                    getCodeSnippet(
+                        frame.fileName,
+                        frame.lineNumber,
+                        frame.columnNumber,
+                    ).then((snippet) => {
+                        resolve({
+                            line_number: frame.lineNumber || 1,
+                            column_number: frame.columnNumber || 1,
+                            method:
+                                frame.functionName ||
+                                'Anonymous or unknown function',
+                            file: frame.fileName || 'Unknown file',
+                            code_snippet: snippet.codeSnippet,
+                            trimmed_column_number: snippet.trimmedColumnNumber,
+                            class: '',
+                        });
+                    });
+                });
+            }),
+        ).then(resolve);
+    });
+}
+
+function hasStack(err: any): boolean {
+    return (
+        !!err &&
+        (!!err.stack || !!err.stacktrace || !!err['opera#sourceloc']) &&
+        typeof (err.stack || err.stacktrace || err['opera#sourceloc']) ===
+            'string' &&
+        err.stack !== `${err.name}: ${err.message}`
+    );
+}

package/src/types.ts

@@ -0,0 +1,92 @@
+export namespace Flare {
+    export type BeforeEvaluate = (
+        error: Error,
+    ) => Error | false | Promise<Error | false>;
+
+    export type BeforeSubmit = (
+        report: ErrorReport,
+    ) => ErrorReport | false | Promise<ErrorReport | false>;
+
+    export type Config = {
+        key: string;
+        reportingUrl: string;
+        maxGlowsPerReport: number;
+        maxReportsPerMinute: number;
+        stage?: string;
+    };
+
+    export type ErrorReport = {
+        notifier: string;
+        exception_class: string;
+        seen_at: number;
+        message: string;
+        language: 'javascript';
+        glows: Array<Flare.Glow>;
+        context: Flare.Context;
+        stacktrace: Array<Flare.StackFrame>;
+        sourcemap_version_id: string;
+        solutions: Array<Flare.Solution>;
+        stage?: string;
+    };
+
+    export interface SolutionProviderExtraParameters {}
+
+    export type SolutionProvider = {
+        canSolve: (
+            error: Error,
+            extraParameters?: SolutionProviderExtraParameters,
+        ) => boolean | Promise<boolean>;
+        getSolutions: (
+            error: Error,
+            extraParameters?: SolutionProviderExtraParameters,
+        ) => Array<Flare.Solution> | Promise<Array<Flare.Solution>>;
+    };
+
+    export type Solution = {
+        class: string;
+        title: string;
+        description: string;
+        links: { [label: string]: string };
+        action_description?: string;
+        is_runnable?: boolean;
+    };
+
+    export type Context = {
+        request?: {
+            url?: String;
+            useragent?: String;
+            referrer?: String; // TODO: Flare doesn't catch this yet
+            readyState?: String; // TODO: Flare doesn't catch this yet
+        };
+        request_data?: {
+            queryString: { [key: string]: string };
+        };
+        cookies?: { [key: string]: string };
+        [key: string]: any;
+    };
+
+    export type StackFrame = {
+        line_number: number;
+        column_number: number; // TODO: Flare doesn't catch this yet
+        method: string;
+        file: string;
+        code_snippet: { [key: number]: string };
+        trimmed_column_number: number | null;
+        class: string;
+    };
+
+    export type Glow = {
+        time: number;
+        microtime: number;
+        name: String;
+        message_level: MessageLevel;
+        meta_data: Array<Object>;
+    };
+
+    export type MessageLevel =
+        | 'info'
+        | 'debug'
+        | 'warning'
+        | 'error'
+        | 'critical';
+}

package/src/util/index.ts

@@ -0,0 +1,44 @@
+import build from '../build';
+
+export function assert(value: any, message: string, debug: boolean) {
+    if (debug && !value) {
+        console.error(
+            `Flare JavaScript client v${build.clientVersion}: ${message}`,
+        );
+    }
+
+    return !!value;
+}
+
+// https://stackoverflow.com/a/11616993/6374824
+export function flatJsonStringify(json: Object): string {
+    let cache: any = [];
+
+    const flattenedStringifiedJson = JSON.stringify(json, function (_, value) {
+        if (typeof value === 'object' && value !== null) {
+            if (cache.indexOf(value) !== -1) {
+                try {
+                    return JSON.parse(JSON.stringify(value));
+                } catch (error) {
+                    return;
+                }
+            }
+            cache.push(value);
+        }
+        return value;
+    });
+
+    cache = null;
+
+    return flattenedStringifiedJson;
+}
+
+export function now(): number {
+    return Math.round(Date.now() / 1000);
+}
+
+export function flattenOnce(array: Array<Array<any>>) {
+    return array.reduce((flat, toFlatten) => {
+        return flat.concat(toFlatten);
+    }, []);
+}

package/tests/index.test.ts

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { flare } from '../src/index';
+import { expect, test } from 'vitest';
+
+test('properly lights', (done) => {
+    const projectKey = 'aprojectkey';
+
+    flare.light(projectKey);
+
+    expect(flare.config.key).toBe(projectKey);
+});
+
+test('can create glows', (done) => {
+    flare.glow('glowName', undefined, undefined);
+
+    expect(flare.glows.length).toBe(1);
+
+    expect(flare.glows[0]).toMatchObject({
+        name: 'glowName',
+        message_level: 'info',
+        meta_data: [],
+    });
+
+    expect(typeof flare.glows[0].microtime).toBe('number');
+    expect(typeof flare.glows[0].time).toBe('number');
+});
+
+test.todo('can register solution providers');
+
+test.todo('can use solution providers properly');
+
+test.todo('can use async solution providers properly');
+
+test.todo('can build an error report from an error');
+
+test.todo('can create custom context and context groups');
+
+test.todo('can throttle when too many reports are being sent');
+
+test.todo('can stop a report from being submitted by using beforeSubmit');
+
+test.todo('can use an async beforeSubmit');
+
+test.todo('can edit a report using beforeSubmit and still send it');
+
+test.todo('can stop an error from being evaluated by using beforeEvaluate');
+
+test.todo('can use an async beforeEvaluate');
+
+test.todo('can check out an error using beforeEvaluate and still send it');

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+    "extends": "../../tsconfig.json",
+    "include": ["src"],
+}