@pixieset/versioning-js 1.0.13

package/LICENSE

@@ -0,0 +1 @@
+Unlicensed

package/README.md

@@ -0,0 +1,87 @@
+# Pixieset Laravel versioning
+This library is meant to augment the Laravel versioning approach created for Studio Manager.  This repository contains
+the front-end code for this project, and should be installed in conjunction with the backend work.
+
+The frontend part contains helpers that can be used to manage the versioning of resources in a frontend application, specifically, the handling of when there are version inconsistencies. 
+
+
+## Contents
+- [Pixieset Laravel versioning](#pixieset-laravel-versioning)
+  - [Contents](#contents)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Bundle development](#bundle-development)
+    - [Prerequisites](#prerequisites)
+    - [Installation](#installation-1)
+    - [Building](#building)
+    - [Pushing changes](#pushing-changes)
+  - [Footnotes](#footnotes)
+---
+
+## Installation
+
+**Prerequisites**:
+
+Currently, this project supports Axios, Laravel, and Capacitor.  You must also have a working Sentry integration in your front-end code already, and you must have installed the backend version checking code.
+
+**Installation**:
+
+The built front-end distribution code for this project is currently publicly available on packagist.   Update your `package.json` file to include the following:
+
+```json
+{
+  "dependencies": {
+    "@pixieset/versioning-js": "^1.0"
+  }
+}
+```
+
+Then run `yarn install` to install the package.
+
+## Usage
+
+For information on versioning usage, see [the Pixieset internal documentation](https://www.notion.so/pixieset/Studio-Manager-Resource-Versioning-WIP-d702c157a24e496e92f869eca2015c1b).
+
+## Bundle development
+
+This section is for developers who want to make changes to the bundle.  It is assumed that you have a Laravel application that you are using to test the changes.
+
+This package uses a Makefile to assist in building the package.  See that file for the commands available, or run `make help` to see a list of available commands in that subfolder.
+
+### Prerequisites
+To build the frontend package, you will need to have the following installed:
+- nodejs, version 18 or higher, with yarn globally.
+- Follow the directions [here](https://classic.yarnpkg.com/lang/en/docs/cli/version/), as well, if you intend to commit.
+
+### Installation
+To make the frontend available locally, you can use the following steps:
+
+1. Clone this repository into a directory of your Laravel application (if you haven't already done so).   Preferably one that will not pollute your primary git source tree.  We're going to use symlinks to connect it in a moment.
+2. In the `versioning-js` portion of the package, invoke `yarn link`.  This will make the package available for local linking and modification.
+3. In your service provider where you are using the package (e.g. Studio Manager), invoke `yarn link @pixieset/versioning-js`.   That will cause `yarn` to symlink the two, so you can make changes locally, and see them every time you run `make build`.
+4. Run your local service provider front end `*-watch` task, to start hot-rebuilding your code based on file changes.
+5. When done, run `yarn unlink @pixieset/versioning-js` within the service provider, to stop using linked code.  Commit and tag your changes. 
+
+
+### Building
+
+The frontend package contains build artifacts in the `dist` subfolder, which are compiled typescript files.  These files are what you should be importing into your Vue components.   Any changes you make to the typescript files in the `src` directory should be compiled into the `dist` directory when you run `make build`.
+
+### Pushing changes
+
+This project uses the [yarn version](https://classic.yarnpkg.com/lang/en/docs/cli/version/) tooling to publish changes. You should have set up your local environment as specified in the prerequisites.
+
+First, set up your pull request, and confirm the changes you'd like to make.   Use `yarn link` as described above, to ensure the changes actually work.
+
+Once the pull request is merged, use `yarn version` as per the yarn documentation to create and publish a new front-end version.  This should:
+
+1. Create a new version number in package.json
+2. Create a new git tag, with the same value.
+
+Push the results of this, using `git push --tags`.   This will trigger the pipeline to create a new build version automatically, and deploy it to NPM for installation.
+
+Remember to unlink yarn before you try to install it.
+
+## Footnotes
+
+- For more information on the technical proposal, see [here](https://www.notion.so/pixieset/Technical-Proposal-SM-API-resource-versioning-41be2336e8f74ce5b1bdbaa04aa04a62?pm=c).

package/dist/ApiVersion.d.ts

@@ -0,0 +1,12 @@
+import VersioningError from "./Error/VersioningError";
+import { VersioningHeaders } from "./types";
+export default class APIVersion {
+    requestedVersion: number;
+    version: number;
+    deprecation: Date | null;
+    sunsetDate: Date | null;
+    availableVersions: number[];
+    errors: VersioningError[];
+    constructor(requestedVersion: number | null, version: number, deprecation: Date | null, sunset: Date | null, availableVersions: number[], errors: VersioningError[]);
+    static fromHeaders(headers: VersioningHeaders): APIVersion;
+}

package/dist/ApiVersion.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VersioningError_1 = __importDefault(require("./Error/VersioningError"));
+const constants_1 = require("./constants");
+function parseVersionInfoValue(value) {
+    const parts = value.split('; ');
+    const responseVersion = parseInt(parts[0], 10);
+    const requestedVersion = parseInt(parts[1].split('=')[1], 10);
+    const availableVersions = parts[2].split('=')[1].split(',').map(v => parseInt(v, 10));
+    const errorReporting = parseInt(parts[3].split('=')[1], 10);
+    return {
+        responseVersion,
+        requestedVersion,
+        availableVersions,
+        errorReporting,
+    };
+}
+class APIVersion {
+    requestedVersion;
+    version;
+    deprecation;
+    sunsetDate;
+    availableVersions;
+    errors;
+    constructor(requestedVersion, version, deprecation, sunset, availableVersions, errors) {
+        this.requestedVersion = requestedVersion ?? constants_1.VERSION_NUMBER_NOT_DEFINED;
+        this.version = version;
+        this.deprecation = deprecation;
+        this.sunsetDate = sunset;
+        this.availableVersions = availableVersions;
+        this.errors = errors;
+    }
+    static fromHeaders(headers) {
+        const lowerCaseHeaders = Object.keys(headers)
+            .reduce((acc, key) => {
+            acc[key.toLowerCase()] = headers[key];
+            return acc;
+        }, {});
+        if (!Object.prototype.hasOwnProperty.call(lowerCaseHeaders, constants_1.VERSION_INFO_HEADER)) {
+            throw new Error('Developer: you have attempted to construct an API version from a response without headers. ' +
+                'Use a static helper method to check if the response is versioned first.');
+        }
+        const parsedVersionInfo = parseVersionInfoValue(lowerCaseHeaders[constants_1.VERSION_INFO_HEADER]);
+        const deprecation = ((value) => {
+            if (!value)
+                return null;
+            if (!value.startsWith('@')) {
+                throw new Error('Deprecation header must start with "@"');
+            }
+            const dateString = value.substring(1);
+            if (!/^\d+$/.test(dateString)) {
+                throw new Error(`Expected a Unix timestamp in Deprecation header, got: ${dateString}`);
+            }
+            const date = new Date(parseInt(dateString, 10) * 1000);
+            if (Number.isNaN(date.getTime())) {
+                throw new Error(`Invalid date in Deprecation header: ${dateString}`);
+            }
+            return date;
+        })(lowerCaseHeaders[constants_1.VERSION_DEPRECATION_HEADER]);
+        const sunset = ((value) => {
+            if (!value)
+                return null;
+            if (Number.isNaN(Date.parse(value))) {
+                throw new Error(`An invalid sunset date {value} was passed.`);
+            }
+            return new Date(value);
+        })(lowerCaseHeaders[constants_1.VERSION_SUNSET_HEADER]);
+        const errors = ((allErrorData) => {
+            if (!allErrorData)
+                return [];
+            const parsedErrorData = JSON.parse(allErrorData);
+            if (!Array.isArray(parsedErrorData)) {
+                throw new Error('Expected an array of VersioningErrorData objects in the error header');
+            }
+            return parsedErrorData.map((errorDataString) => {
+                const errorData = JSON.parse(errorDataString);
+                if (!Object.prototype.hasOwnProperty.call(errorData, 'error')) {
+                    throw new Error('Expected an error message in the error data');
+                }
+                if (!Object.prototype.hasOwnProperty.call(errorData, 'level')) {
+                    throw new Error('Expected an error level in the error data');
+                }
+                if (!Object.prototype.hasOwnProperty.call(errorData, 'code')) {
+                    throw new Error('Expected an error code in the error data');
+                }
+                if (errorData.level === 'alert' || errorData.level === 'critical' || errorData.level === 'emergency') {
+                    errorData.level = 'fatal';
+                }
+                return new VersioningError_1.default(errorData.error, errorData.level, errorData.code, sunset);
+            });
+        })(lowerCaseHeaders[constants_1.VERSION_ERRORS_HEADER]);
+        return new APIVersion(parsedVersionInfo.requestedVersion, parsedVersionInfo.responseVersion, deprecation, sunset, parsedVersionInfo.availableVersions, errors);
+    }
+}
+exports.default = APIVersion;

package/dist/Error/VersioningError.d.ts

@@ -0,0 +1,8 @@
+import { VERSION_ERROR_LEVEL_ERROR, VERSION_ERROR_LEVEL_FATAL, VERSION_ERROR_LEVEL_WARNING } from "../constants";
+export type VersionErrorLevel = typeof VERSION_ERROR_LEVEL_WARNING | typeof VERSION_ERROR_LEVEL_ERROR | typeof VERSION_ERROR_LEVEL_FATAL | null;
+export default class VersioningError extends Error {
+    level: 'warning' | 'error' | 'fatal';
+    code: string;
+    sunsetDate: Date | null;
+    constructor(message: string, level: string, code: string, sunsetDate?: Date | null);
+}

package/dist/Error/VersioningError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+class VersioningError extends Error {
+    level;
+    code;
+    sunsetDate;
+    constructor(message, level, code, sunsetDate = null) {
+        super(message);
+        this.name = 'VersionMismatchError';
+        if (![constants_1.VERSION_ERROR_LEVEL_WARNING, constants_1.VERSION_ERROR_LEVEL_ERROR, constants_1.VERSION_ERROR_LEVEL_FATAL].includes(level)) {
+            throw Error('Developer: you have passed an invalid error level: ' + level);
+        }
+        this.level = level;
+        this.code = code;
+        this.sunsetDate = sunsetDate;
+    }
+}
+exports.default = VersioningError;

package/dist/axios_helpers.d.ts

@@ -0,0 +1,14 @@
+import { AxiosResponse, AxiosInstance } from "axios";
+import APIVersion from "./ApiVersion";
+export declare const useVersion: (version: number) => {
+    transformRequest: ((data: object, headers: {
+        [key: string]: string;
+    }) => object)[];
+};
+export declare function handleVersioningErrorsInAxiosResponse(response: AxiosResponse): Promise<void>;
+declare const _default: {
+    bindAxiosVersioningResponseErrorListener: (instance: AxiosInstance) => void;
+    isAxiosResponseVersioned: (response: AxiosResponse<any, any>) => boolean;
+    fromAxiosResponse: (response: AxiosResponse<any, any>) => APIVersion;
+};
+export default _default;

package/dist/axios_helpers.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleVersioningErrorsInAxiosResponse = exports.useVersion = void 0;
+const ApiVersion_1 = __importDefault(require("./ApiVersion"));
+const sentry_1 = require("./sentry");
+const constants_1 = require("./constants");
+const helpers_1 = __importDefault(require("./helpers"));
+const useVersion = (version) => {
+    return {
+        transformRequest: [(data, headers) => {
+                headers['Accept-Version'] = version.toString();
+                return data;
+            }],
+    };
+};
+exports.useVersion = useVersion;
+const isAxiosResponseVersioned = (response) => {
+    return Object.prototype.hasOwnProperty.call(response.headers, constants_1.VERSION_INFO_HEADER);
+};
+const fromAxiosResponse = (response) => {
+    if (!isAxiosResponseVersioned(response)) {
+        throw new Error('Developer: you have attempted to construct an API version from a response without headers. ' +
+            'Use the static isVersioned method to check if the response is versioned first.');
+    }
+    return ApiVersion_1.default.fromHeaders(response.headers);
+};
+async function handleVersioningErrorsInAxiosResponse(response) {
+    if (response.status > 300) {
+        return;
+    }
+    if (!(response.request instanceof XMLHttpRequest)) {
+        return;
+    }
+    if (!isAxiosResponseVersioned(response)) {
+        return;
+    }
+    let apiVersion;
+    try {
+        apiVersion = fromAxiosResponse(response);
+    }
+    catch (e) {
+        console.error('Pixieset Versioning: Error constructing API version from response', e, response);
+        return;
+    }
+    const url = response.request.responseURL;
+    if (apiVersion.errors.length === 0) {
+        return;
+    }
+    const Sentry = await (0, sentry_1.getSentry)();
+    apiVersion.errors.forEach((error) => {
+        const baseStyle = '';
+        let style;
+        let logFunction;
+        let emoji;
+        switch (error.level) {
+            case constants_1.VERSION_ERROR_LEVEL_WARNING:
+                style = `${baseStyle}`;
+                logFunction = 'warn';
+                emoji = '⚠️';
+                break;
+            case constants_1.VERSION_ERROR_LEVEL_ERROR:
+                style = `${baseStyle}`;
+                logFunction = 'error';
+                emoji = '🚫';
+                break;
+            case constants_1.VERSION_ERROR_LEVEL_FATAL:
+                style = `${baseStyle} font-size: 14px;`;
+                logFunction = 'error';
+                emoji = '🚫';
+                break;
+        }
+        console[logFunction](`%c${emoji} ${error.level.toUpperCase()}: ${error.message}`, style, {
+            url,
+            stacktrace: (0, helpers_1.default)(error.stack),
+        });
+        if (!Sentry || error.level === constants_1.VERSION_ERROR_LEVEL_WARNING) {
+            return;
+        }
+        Sentry.captureException(error, {
+            level: error.level,
+            extra: {
+                url,
+                stacktrace: error.stack ?? '[stack trace not available]',
+            },
+        });
+    });
+}
+exports.handleVersioningErrorsInAxiosResponse = handleVersioningErrorsInAxiosResponse;
+const bindAxiosVersioningResponseErrorListener = (instance) => {
+    instance.interceptors.response.use(async (response) => {
+        await handleVersioningErrorsInAxiosResponse(response);
+        return response;
+    });
+};
+exports.default = {
+    bindAxiosVersioningResponseErrorListener,
+    isAxiosResponseVersioned,
+    fromAxiosResponse,
+};

package/dist/capacitor_helpers.d.ts

@@ -0,0 +1,16 @@
+import VersioningError from "./Error/VersioningError";
+import { ExclusiveEventHintOrCaptureContext } from '@sentry/core/build/types-ts3.8/utils/prepareEvent';
+interface HttpResponse {
+    headers: Record<string, string>;
+    status: number;
+    url: string;
+}
+interface HttpOptions {
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+declare const _default: {
+    useVersion: (version: number, existingOptions: HttpOptions) => HttpOptions;
+    handleVersioningErrorsInCapacitorResponse: (response: HttpResponse, captureExceptionCallback: (error: VersioningError, hint: ExclusiveEventHintOrCaptureContext) => void) => Promise<void>;
+};
+export default _default;

package/dist/capacitor_helpers.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiVersion_1 = __importDefault(require("./ApiVersion"));
+const constants_1 = require("./constants");
+const helpers_1 = __importDefault(require("./helpers"));
+const useVersion = (version, existingOptions) => {
+    return {
+        ...existingOptions,
+        headers: {
+            ...existingOptions.headers,
+            'Accept-Version': version.toString()
+        }
+    };
+};
+const isCapacitorResponseVersioned = (response) => {
+    return Object.prototype.hasOwnProperty.call(response.headers, constants_1.VERSION_INFO_HEADER);
+};
+const fromCapacitorResponse = (response) => {
+    if (!isCapacitorResponseVersioned(response)) {
+        throw new Error('Developer: you have attempted to construct an API version from a response without headers. ' +
+            'Use the static isVersioned method to check if the response is versioned first.');
+    }
+    return ApiVersion_1.default.fromHeaders(response.headers);
+};
+const handleVersioningErrorsInCapacitorResponse = async (response, captureExceptionCallback) => {
+    if (response.status > 300) {
+        return;
+    }
+    if (!isCapacitorResponseVersioned(response)) {
+        return;
+    }
+    let apiVersion;
+    try {
+        apiVersion = fromCapacitorResponse(response);
+    }
+    catch (e) {
+        console.error('Pixieset Versioning: Error constructing API version from response', e, response);
+        return;
+    }
+    const url = response.url;
+    if (apiVersion.errors.length === 0) {
+        return;
+    }
+    apiVersion.errors.forEach((error) => {
+        const baseStyle = '';
+        let style;
+        let logFunction;
+        let emoji;
+        switch (error.level) {
+            case constants_1.VERSION_ERROR_LEVEL_WARNING:
+                style = `${baseStyle}`;
+                logFunction = 'warn';
+                emoji = '⚠️';
+                break;
+            case constants_1.VERSION_ERROR_LEVEL_ERROR:
+                style = `${baseStyle}`;
+                logFunction = 'error';
+                emoji = '🚫';
+                break;
+            case constants_1.VERSION_ERROR_LEVEL_FATAL:
+                style = `${baseStyle} font-size: 14px;`;
+                logFunction = 'error';
+                emoji = '🚫';
+                break;
+        }
+        console[logFunction](`%c${emoji} ${error.level.toUpperCase()}: ${error.message}`, style, {
+            url,
+            stacktrace: (0, helpers_1.default)(error.stack),
+        });
+        if (error.level === constants_1.VERSION_ERROR_LEVEL_WARNING) {
+            return;
+        }
+        captureExceptionCallback(error, {
+            captureContext: {
+                level: error.level,
+                extra: {
+                    url,
+                    stacktrace: error.stack ?? '[stack trace not available]',
+                },
+            },
+        });
+    });
+};
+exports.default = {
+    useVersion,
+    handleVersioningErrorsInCapacitorResponse,
+};

package/dist/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const ERROR_REPORTING_NONE = 0;
+export declare const ERROR_REPORTING_SHOW_CONSOLE_ERRORS = 1;
+export declare const ERROR_REPORTING_SHOW_SENTRY_ERRORS = 2;
+export declare const ERROR_REPORTING_ALL = 3;
+export declare const VERSION_ERROR_LEVEL_WARNING = "warning";
+export declare const VERSION_ERROR_LEVEL_ERROR = "error";
+export declare const VERSION_ERROR_LEVEL_FATAL = "fatal";
+export declare const VERSION_NUMBER_NOT_DEFINED = -1;
+export declare const VERSION_INFO_HEADER = "x-api-version-info";
+export declare const VERSION_ERRORS_HEADER = "x-api-version-errors";
+export declare const VERSION_DEPRECATION_HEADER = "deprecation";
+export declare const VERSION_SUNSET_HEADER = "sunset";

package/dist/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_SUNSET_HEADER = exports.VERSION_DEPRECATION_HEADER = exports.VERSION_ERRORS_HEADER = exports.VERSION_INFO_HEADER = exports.VERSION_NUMBER_NOT_DEFINED = exports.VERSION_ERROR_LEVEL_FATAL = exports.VERSION_ERROR_LEVEL_ERROR = exports.VERSION_ERROR_LEVEL_WARNING = exports.ERROR_REPORTING_ALL = exports.ERROR_REPORTING_SHOW_SENTRY_ERRORS = exports.ERROR_REPORTING_SHOW_CONSOLE_ERRORS = exports.ERROR_REPORTING_NONE = void 0;
+exports.ERROR_REPORTING_NONE = 0;
+exports.ERROR_REPORTING_SHOW_CONSOLE_ERRORS = 1;
+exports.ERROR_REPORTING_SHOW_SENTRY_ERRORS = 2;
+exports.ERROR_REPORTING_ALL = 3;
+exports.VERSION_ERROR_LEVEL_WARNING = 'warning';
+exports.VERSION_ERROR_LEVEL_ERROR = 'error';
+exports.VERSION_ERROR_LEVEL_FATAL = 'fatal';
+exports.VERSION_NUMBER_NOT_DEFINED = -1;
+exports.VERSION_INFO_HEADER = 'x-api-version-info';
+exports.VERSION_ERRORS_HEADER = 'x-api-version-errors';
+exports.VERSION_DEPRECATION_HEADER = 'deprecation';
+exports.VERSION_SUNSET_HEADER = 'sunset';

package/dist/helpers.d.ts

@@ -0,0 +1,4 @@
+declare const traceToObject: (stack: string | undefined) => {
+    [key: string]: string;
+};
+export default traceToObject;

package/dist/helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const traceToObject = (stack) => {
+    if (stack === undefined) {
+        return {};
+    }
+    const stackLines = stack.split('\n');
+    const parsedStack = {};
+    stackLines.forEach((line, index) => {
+        if (line.trim()) {
+            parsedStack[`- ${index}`] = line.trim();
+        }
+    });
+    return parsedStack;
+};
+exports.default = traceToObject;

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from './ApiVersion';
+export * from './Error/VersioningError';
+export * from './axios_helpers';
+export { useVersion } from './axios_helpers';
+export { ERROR_REPORTING_ALL } from "./constants";
+export { ERROR_REPORTING_SHOW_SENTRY_ERRORS } from "./constants";
+export { ERROR_REPORTING_SHOW_CONSOLE_ERRORS } from "./constants";
+export { ERROR_REPORTING_NONE } from "./constants";
+export { VERSION_ERROR_LEVEL_FATAL } from "./constants";
+export { VERSION_ERROR_LEVEL_ERROR } from "./constants";
+export { VERSION_ERROR_LEVEL_WARNING } from "./constants";
+export { VERSION_SUNSET_HEADER } from "./constants";
+export { VERSION_DEPRECATION_HEADER } from "./constants";
+export { VERSION_INFO_HEADER } from "./constants";
+export { VERSION_NUMBER_NOT_DEFINED } from "./constants";
+export { VersioningHeaders } from "./types";
+export { VersionSunsetDate } from "./types";
+export { VersionDeprecation } from "./types";
+export { VersionInfo } from "./types";
+export { VersionInfoValue } from "./types";

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_NUMBER_NOT_DEFINED = exports.VERSION_INFO_HEADER = exports.VERSION_DEPRECATION_HEADER = exports.VERSION_SUNSET_HEADER = exports.VERSION_ERROR_LEVEL_WARNING = exports.VERSION_ERROR_LEVEL_ERROR = exports.VERSION_ERROR_LEVEL_FATAL = exports.ERROR_REPORTING_NONE = exports.ERROR_REPORTING_SHOW_CONSOLE_ERRORS = exports.ERROR_REPORTING_SHOW_SENTRY_ERRORS = exports.ERROR_REPORTING_ALL = exports.useVersion = void 0;
+__exportStar(require("./ApiVersion"), exports);
+__exportStar(require("./Error/VersioningError"), exports);
+__exportStar(require("./axios_helpers"), exports);
+var axios_helpers_1 = require("./axios_helpers");
+Object.defineProperty(exports, "useVersion", { enumerable: true, get: function () { return axios_helpers_1.useVersion; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "ERROR_REPORTING_ALL", { enumerable: true, get: function () { return constants_1.ERROR_REPORTING_ALL; } });
+var constants_2 = require("./constants");
+Object.defineProperty(exports, "ERROR_REPORTING_SHOW_SENTRY_ERRORS", { enumerable: true, get: function () { return constants_2.ERROR_REPORTING_SHOW_SENTRY_ERRORS; } });
+var constants_3 = require("./constants");
+Object.defineProperty(exports, "ERROR_REPORTING_SHOW_CONSOLE_ERRORS", { enumerable: true, get: function () { return constants_3.ERROR_REPORTING_SHOW_CONSOLE_ERRORS; } });
+var constants_4 = require("./constants");
+Object.defineProperty(exports, "ERROR_REPORTING_NONE", { enumerable: true, get: function () { return constants_4.ERROR_REPORTING_NONE; } });
+var constants_5 = require("./constants");
+Object.defineProperty(exports, "VERSION_ERROR_LEVEL_FATAL", { enumerable: true, get: function () { return constants_5.VERSION_ERROR_LEVEL_FATAL; } });
+var constants_6 = require("./constants");
+Object.defineProperty(exports, "VERSION_ERROR_LEVEL_ERROR", { enumerable: true, get: function () { return constants_6.VERSION_ERROR_LEVEL_ERROR; } });
+var constants_7 = require("./constants");
+Object.defineProperty(exports, "VERSION_ERROR_LEVEL_WARNING", { enumerable: true, get: function () { return constants_7.VERSION_ERROR_LEVEL_WARNING; } });
+var constants_8 = require("./constants");
+Object.defineProperty(exports, "VERSION_SUNSET_HEADER", { enumerable: true, get: function () { return constants_8.VERSION_SUNSET_HEADER; } });
+var constants_9 = require("./constants");
+Object.defineProperty(exports, "VERSION_DEPRECATION_HEADER", { enumerable: true, get: function () { return constants_9.VERSION_DEPRECATION_HEADER; } });
+var constants_10 = require("./constants");
+Object.defineProperty(exports, "VERSION_INFO_HEADER", { enumerable: true, get: function () { return constants_10.VERSION_INFO_HEADER; } });
+var constants_11 = require("./constants");
+Object.defineProperty(exports, "VERSION_NUMBER_NOT_DEFINED", { enumerable: true, get: function () { return constants_11.VERSION_NUMBER_NOT_DEFINED; } });

package/dist/sentry.d.ts

@@ -0,0 +1,9 @@
+import { captureMessage, captureException } from "@sentry/core/build/types-ts3.8";
+export type SentryCore = {
+    captureMessage: typeof captureMessage;
+    captureException: typeof captureException;
+};
+declare global {
+    var Sentry: SentryCore | undefined;
+}
+export declare function getSentry(): Promise<SentryCore | undefined>;

package/dist/sentry.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSentry = void 0;
+async function getSentry() {
+    if (typeof global.Sentry !== "object") {
+        return undefined;
+    }
+    if (typeof global.Sentry.captureMessage !== "function"
+        || typeof global.Sentry.captureException !== "function") {
+        return undefined;
+    }
+    return global.Sentry;
+}
+exports.getSentry = getSentry;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@pixieset/versioning-js",
+  "version": "1.0.13",
+  "description": "Front end support for Pixieset versioning",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git@bitbucket.org:pixieset/versioning-js.git"
+  },
+  "author": "Aron Beal <aron.beal@pixieset.com>",
+  "license": "UNLICENSED",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/axios": "^0.14",
+    "@types/jest": "^29",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "eslint": "^8",
+    "jest": "^29",
+    "jest-resolve": "^29",
+    "ts-jest": "^29",
+    "ts-node": "^10",
+    "typescript": "5.1"
+  },
+  "dependencies": {
+    "@sentry/core": "^8",
+    "@sentry/types": "^8",
+    "@types/node": "^20",
+    "axios": "^1.7.7"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts,.tsx --fix",
+    "test": "TZ=UTC jest",
+    "prepack": "yarn build",
+    "preversion": "yarn test",
+    "version": "yarn build"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "keywords": [
+    "pixieset",
+    "versioning"
+  ],
+  "bugs": {
+    "url": "https://bitbucket.org/pixieset/versioning-js/issues"
+  },
+  "homepage": "https://bitbucket.org/pixieset/versioning-js#readme"
+}