@mui/internal-docs-infra
Version:
MUI Infra - internal documentation creation tools.
441 lines (421 loc) • 30.6 kB
JavaScript
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _callSuper from "@babel/runtime/helpers/esm/callSuper";
import _inherits from "@babel/runtime/helpers/esm/inherits";
import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
// Base error class for all CodeHighlighter errors
export var ErrorCodeHighlighter = /*#__PURE__*/function (_Error) {
function ErrorCodeHighlighter(message) {
var _this;
_classCallCheck(this, ErrorCodeHighlighter);
_this = _callSuper(this, ErrorCodeHighlighter, ["CodeHighlighter: ".concat(message)]);
_this.name = _this.constructor.name;
return _this;
}
_inherits(ErrorCodeHighlighter, _Error);
return _createClass(ErrorCodeHighlighter);
}(/*#__PURE__*/_wrapNativeSuper(Error));
// Server-side errors (during SSR/precomputation)
export var ErrorCodeHighlighterServer = /*#__PURE__*/function (_ErrorCodeHighlighter) {
function ErrorCodeHighlighterServer(message) {
_classCallCheck(this, ErrorCodeHighlighterServer);
return _callSuper(this, ErrorCodeHighlighterServer, ["[Server] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterServer, _ErrorCodeHighlighter);
return _createClass(ErrorCodeHighlighterServer);
}(ErrorCodeHighlighter);
// Client-side errors (during hydration/runtime)
export var ErrorCodeHighlighterClient = /*#__PURE__*/function (_ErrorCodeHighlighter2) {
function ErrorCodeHighlighterClient(message) {
_classCallCheck(this, ErrorCodeHighlighterClient);
return _callSuper(this, ErrorCodeHighlighterClient, ["[Client] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterClient, _ErrorCodeHighlighter2);
return _createClass(ErrorCodeHighlighterClient);
}(ErrorCodeHighlighter);
// === SERVER ERROR TYPES ===
// Configuration errors on server
export var ErrorCodeHighlighterServerConfiguration = /*#__PURE__*/function (_ErrorCodeHighlighter3) {
function ErrorCodeHighlighterServerConfiguration(message) {
_classCallCheck(this, ErrorCodeHighlighterServerConfiguration);
return _callSuper(this, ErrorCodeHighlighterServerConfiguration, ["[Configuration] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterServerConfiguration, _ErrorCodeHighlighter3);
return _createClass(ErrorCodeHighlighterServerConfiguration);
}(ErrorCodeHighlighterServer);
// Loading errors on server
export var ErrorCodeHighlighterServerLoader = /*#__PURE__*/function (_ErrorCodeHighlighter4) {
function ErrorCodeHighlighterServerLoader(message) {
_classCallCheck(this, ErrorCodeHighlighterServerLoader);
return _callSuper(this, ErrorCodeHighlighterServerLoader, ["[Loader] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterServerLoader, _ErrorCodeHighlighter4);
return _createClass(ErrorCodeHighlighterServerLoader);
}(ErrorCodeHighlighterServer);
// Validation errors on server
export var ErrorCodeHighlighterServerValidation = /*#__PURE__*/function (_ErrorCodeHighlighter5) {
function ErrorCodeHighlighterServerValidation(message) {
_classCallCheck(this, ErrorCodeHighlighterServerValidation);
return _callSuper(this, ErrorCodeHighlighterServerValidation, ["[Validation] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterServerValidation, _ErrorCodeHighlighter5);
return _createClass(ErrorCodeHighlighterServerValidation);
}(ErrorCodeHighlighterServer);
// === CLIENT ERROR TYPES ===
// Configuration errors on client
export var ErrorCodeHighlighterClientConfiguration = /*#__PURE__*/function (_ErrorCodeHighlighter6) {
function ErrorCodeHighlighterClientConfiguration(message) {
_classCallCheck(this, ErrorCodeHighlighterClientConfiguration);
return _callSuper(this, ErrorCodeHighlighterClientConfiguration, ["[Configuration] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterClientConfiguration, _ErrorCodeHighlighter6);
return _createClass(ErrorCodeHighlighterClientConfiguration);
}(ErrorCodeHighlighterClient);
// Loading errors on client
export var ErrorCodeHighlighterClientLoader = /*#__PURE__*/function (_ErrorCodeHighlighter7) {
function ErrorCodeHighlighterClientLoader(message) {
_classCallCheck(this, ErrorCodeHighlighterClientLoader);
return _callSuper(this, ErrorCodeHighlighterClientLoader, ["[Loader] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterClientLoader, _ErrorCodeHighlighter7);
return _createClass(ErrorCodeHighlighterClientLoader);
}(ErrorCodeHighlighterClient);
// Validation errors on client
export var ErrorCodeHighlighterClientValidation = /*#__PURE__*/function (_ErrorCodeHighlighter8) {
function ErrorCodeHighlighterClientValidation(message) {
_classCallCheck(this, ErrorCodeHighlighterClientValidation);
return _callSuper(this, ErrorCodeHighlighterClientValidation, ["[Validation] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterClientValidation, _ErrorCodeHighlighter8);
return _createClass(ErrorCodeHighlighterClientValidation);
}(ErrorCodeHighlighterClient);
// Provider errors on client
export var ErrorCodeHighlighterClientProvider = /*#__PURE__*/function (_ErrorCodeHighlighter9) {
function ErrorCodeHighlighterClientProvider(message) {
_classCallCheck(this, ErrorCodeHighlighterClientProvider);
return _callSuper(this, ErrorCodeHighlighterClientProvider, ["[Provider] ".concat(message)]);
}
_inherits(ErrorCodeHighlighterClientProvider, _ErrorCodeHighlighter9);
return _createClass(ErrorCodeHighlighterClientProvider);
}(ErrorCodeHighlighterClient);
// === SERVER SPECIFIC ERRORS ===
// Server Configuration Errors
export var ErrorCodeHighlighterServerMissingLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter0) {
function ErrorCodeHighlighterServerMissingLoadCodeMeta(context) {
_classCallCheck(this, ErrorCodeHighlighterServerMissingLoadCodeMeta);
var message = context ? "Missing loadCodeMeta function - ".concat(context) : 'Missing loadCodeMeta function - No code provided and "loadCodeMeta" function is not defined';
return _callSuper(this, ErrorCodeHighlighterServerMissingLoadCodeMeta, [message]);
}
_inherits(ErrorCodeHighlighterServerMissingLoadCodeMeta, _ErrorCodeHighlighter0);
return _createClass(ErrorCodeHighlighterServerMissingLoadCodeMeta);
}(ErrorCodeHighlighterServerConfiguration);
export var ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter1) {
function ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals() {
_classCallCheck(this, ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals);
return _callSuper(this, ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals, ['Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs']);
}
_inherits(ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals, _ErrorCodeHighlighter1);
return _createClass(ErrorCodeHighlighterServerMissingLoadCodeMetaForGlobals);
}(ErrorCodeHighlighterServerConfiguration);
export var ErrorCodeHighlighterServerMissingUrl = /*#__PURE__*/function (_ErrorCodeHighlighter10) {
function ErrorCodeHighlighterServerMissingUrl(context) {
_classCallCheck(this, ErrorCodeHighlighterServerMissingUrl);
var message = context ? "Missing URL - URL is required ".concat(context) : 'Missing URL - URL is required for loading initial source';
return _callSuper(this, ErrorCodeHighlighterServerMissingUrl, [message]);
}
_inherits(ErrorCodeHighlighterServerMissingUrl, _ErrorCodeHighlighter10);
return _createClass(ErrorCodeHighlighterServerMissingUrl);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter11) {
function ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta() {
_classCallCheck(this, ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta);
return _callSuper(this, ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta, ['Missing URL - URL is required when loading code with "loadCodeMeta"']);
}
_inherits(ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta, _ErrorCodeHighlighter11);
return _createClass(ErrorCodeHighlighterServerMissingUrlForLoadCodeMeta);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerInvalidProps = /*#__PURE__*/function (_ErrorCodeHighlighter12) {
function ErrorCodeHighlighterServerInvalidProps() {
_classCallCheck(this, ErrorCodeHighlighterServerInvalidProps);
return _callSuper(this, ErrorCodeHighlighterServerInvalidProps, ['Invalid props - Cannot provide both "children" and "code" or "precompute" props']);
}
_inherits(ErrorCodeHighlighterServerInvalidProps, _ErrorCodeHighlighter12);
return _createClass(ErrorCodeHighlighterServerInvalidProps);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerMissingData = /*#__PURE__*/function (_ErrorCodeHighlighter13) {
function ErrorCodeHighlighterServerMissingData() {
_classCallCheck(this, ErrorCodeHighlighterServerMissingData);
return _callSuper(this, ErrorCodeHighlighterServerMissingData, ['Missing data - No code or components provided']);
}
_inherits(ErrorCodeHighlighterServerMissingData, _ErrorCodeHighlighter13);
return _createClass(ErrorCodeHighlighterServerMissingData);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerMissingVariant = /*#__PURE__*/function (_ErrorCodeHighlighter14) {
function ErrorCodeHighlighterServerMissingVariant(variantName) {
_classCallCheck(this, ErrorCodeHighlighterServerMissingVariant);
return _callSuper(this, ErrorCodeHighlighterServerMissingVariant, ["Missing variant - No code or component for variant \"".concat(variantName, "\"")]);
}
_inherits(ErrorCodeHighlighterServerMissingVariant, _ErrorCodeHighlighter14);
return _createClass(ErrorCodeHighlighterServerMissingVariant);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerMissingFileName = /*#__PURE__*/function (_ErrorCodeHighlighter15) {
function ErrorCodeHighlighterServerMissingFileName(variantName) {
_classCallCheck(this, ErrorCodeHighlighterServerMissingFileName);
return _callSuper(this, ErrorCodeHighlighterServerMissingFileName, ["Missing fileName - fileName or url is required for variant \"".concat(variantName, "\" when extraFiles are provided")]);
}
_inherits(ErrorCodeHighlighterServerMissingFileName, _ErrorCodeHighlighter15);
return _createClass(ErrorCodeHighlighterServerMissingFileName);
}(ErrorCodeHighlighterServerValidation);
export var ErrorCodeHighlighterServerMissingContentLoading = /*#__PURE__*/function (_ErrorCodeHighlighter16) {
function ErrorCodeHighlighterServerMissingContentLoading() {
_classCallCheck(this, ErrorCodeHighlighterServerMissingContentLoading);
return _callSuper(this, ErrorCodeHighlighterServerMissingContentLoading, ["Missing ContentLoading component - ContentLoading component is required for stream highlighting"]);
}
_inherits(ErrorCodeHighlighterServerMissingContentLoading, _ErrorCodeHighlighter16);
return _createClass(ErrorCodeHighlighterServerMissingContentLoading);
}(ErrorCodeHighlighterServerConfiguration);
export var ErrorCodeHighlighterServerInvalidClientMode = /*#__PURE__*/function (_ErrorCodeHighlighter17) {
function ErrorCodeHighlighterServerInvalidClientMode() {
_classCallCheck(this, ErrorCodeHighlighterServerInvalidClientMode);
return _callSuper(this, ErrorCodeHighlighterServerInvalidClientMode, ["Invalid client mode - Client only mode with highlightAfter: init requires precomputed and parsed source code"]);
}
_inherits(ErrorCodeHighlighterServerInvalidClientMode, _ErrorCodeHighlighter17);
return _createClass(ErrorCodeHighlighterServerInvalidClientMode);
}(ErrorCodeHighlighterServerValidation);
// Server Loading Errors
export var ErrorCodeHighlighterServerLoadCodeFailure = /*#__PURE__*/function (_ErrorCodeHighlighter18) {
function ErrorCodeHighlighterServerLoadCodeFailure(url, error) {
_classCallCheck(this, ErrorCodeHighlighterServerLoadCodeFailure);
return _callSuper(this, ErrorCodeHighlighterServerLoadCodeFailure, ["Failed to load code from URL:\n\n".concat(url, "\n\nError:\n").concat(JSON.stringify(error, null, 2))]);
}
_inherits(ErrorCodeHighlighterServerLoadCodeFailure, _ErrorCodeHighlighter18);
return _createClass(ErrorCodeHighlighterServerLoadCodeFailure);
}(ErrorCodeHighlighterServerLoader);
export var ErrorCodeHighlighterServerLoadGlobalsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter19) {
function ErrorCodeHighlighterServerLoadGlobalsFailure(url, error) {
_classCallCheck(this, ErrorCodeHighlighterServerLoadGlobalsFailure);
return _callSuper(this, ErrorCodeHighlighterServerLoadGlobalsFailure, ["Failed to load globalsCode from URL:\n\n".concat(url, "\n\nError:\n").concat(JSON.stringify(error, null, 2))]);
}
_inherits(ErrorCodeHighlighterServerLoadGlobalsFailure, _ErrorCodeHighlighter19);
return _createClass(ErrorCodeHighlighterServerLoadGlobalsFailure);
}(ErrorCodeHighlighterServerLoader);
export var ErrorCodeHighlighterServerLoadVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter20) {
function ErrorCodeHighlighterServerLoadVariantsFailure(url, errors) {
_classCallCheck(this, ErrorCodeHighlighterServerLoadVariantsFailure);
return _callSuper(this, ErrorCodeHighlighterServerLoadVariantsFailure, ["Failed to load all variants of URL:\n\n".concat(url, ":\n\n").concat(errors.map(function (error) {
return error.message;
}).join('\n'))]);
}
_inherits(ErrorCodeHighlighterServerLoadVariantsFailure, _ErrorCodeHighlighter20);
return _createClass(ErrorCodeHighlighterServerLoadVariantsFailure);
}(ErrorCodeHighlighterServerLoader);
// === CLIENT SPECIFIC ERRORS ===
// Client Provider Errors
export var ErrorCodeHighlighterClientMissingLoadFallbackCode = /*#__PURE__*/function (_ErrorCodeHighlighter21) {
function ErrorCodeHighlighterClientMissingLoadFallbackCode(url) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadFallbackCode);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadFallbackCode, ["Missing loadFallbackCode function - loadFallbackCode is required (".concat(url || 'No URL', ") add a <CodeProvider />")]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadFallbackCode, _ErrorCodeHighlighter21);
return _createClass(ErrorCodeHighlighterClientMissingLoadFallbackCode);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadVariant = /*#__PURE__*/function (_ErrorCodeHighlighter22) {
function ErrorCodeHighlighterClientMissingLoadVariant(url) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadVariant);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadVariant, ["Missing loadVariant function - loadVariant function is required when no initial code is provided (".concat(url || 'No URL', ")")]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadVariant, _ErrorCodeHighlighter22);
return _createClass(ErrorCodeHighlighterClientMissingLoadVariant);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadCodeMeta = /*#__PURE__*/function (_ErrorCodeHighlighter23) {
function ErrorCodeHighlighterClientMissingLoadCodeMeta(context) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMeta);
var message = context ? "Missing loadCodeMeta function - ".concat(context) : 'Missing loadCodeMeta function - loadCodeMeta is required';
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMeta, [message]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadCodeMeta, _ErrorCodeHighlighter23);
return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMeta);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode = /*#__PURE__*/function (_ErrorCodeHighlighter24) {
function ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode(url) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode, ["Missing loadCodeMeta function - loadCodeMeta function is required when no code is provided (".concat(url || 'No URL', ")")]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode, _ErrorCodeHighlighter24);
return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForNoCode);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter25) {
function ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals, ["Missing loadCodeMeta function - loadCodeMeta function is required when globalsCode contains string URLs"]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals, _ErrorCodeHighlighter25);
return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForGlobals);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls = /*#__PURE__*/function (_ErrorCodeHighlighter26) {
function ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls, ["Missing loadCodeMeta function - \"loadCodeMeta\" function is required for string URLs in globalsCode"]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls, _ErrorCodeHighlighter26);
return _createClass(ErrorCodeHighlighterClientMissingLoadCodeMetaForStringUrls);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadSource = /*#__PURE__*/function (_ErrorCodeHighlighter27) {
function ErrorCodeHighlighterClientMissingLoadSource(context) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSource);
var message = context ? "Missing loadSource function - ".concat(context) : 'Missing loadSource function - loadSource function is required when no code is provided';
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSource, [message]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadSource, _ErrorCodeHighlighter27);
return _createClass(ErrorCodeHighlighterClientMissingLoadSource);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadSourceForNoCode = /*#__PURE__*/function (_ErrorCodeHighlighter28) {
function ErrorCodeHighlighterClientMissingLoadSourceForNoCode() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSourceForNoCode);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSourceForNoCode, ["Missing loadSource function - loadSource function is required when no code is provided"]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadSourceForNoCode, _ErrorCodeHighlighter28);
return _createClass(ErrorCodeHighlighterClientMissingLoadSourceForNoCode);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls = /*#__PURE__*/function (_ErrorCodeHighlighter29) {
function ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls, ["Missing loadSource function - loadSource function is required when code contains unloaded URLs"]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls, _ErrorCodeHighlighter29);
return _createClass(ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls);
}(ErrorCodeHighlighterClientProvider);
// Client Validation Errors
export var ErrorCodeHighlighterClientMissingUrl = /*#__PURE__*/function (_ErrorCodeHighlighter30) {
function ErrorCodeHighlighterClientMissingUrl(context) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingUrl);
var message = context ? "Missing URL - ".concat(context) : 'Missing URL - URL is required for loading fallback data when no initial code is provided';
return _callSuper(this, ErrorCodeHighlighterClientMissingUrl, [message]);
}
_inherits(ErrorCodeHighlighterClientMissingUrl, _ErrorCodeHighlighter30);
return _createClass(ErrorCodeHighlighterClientMissingUrl);
}(ErrorCodeHighlighterClientValidation);
export var ErrorCodeHighlighterClientMissingUrlForFallback = /*#__PURE__*/function (_ErrorCodeHighlighter31) {
function ErrorCodeHighlighterClientMissingUrlForFallback() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingUrlForFallback);
return _callSuper(this, ErrorCodeHighlighterClientMissingUrlForFallback, ["Missing URL - URL is required for loading fallback data when no initial code is provided"]);
}
_inherits(ErrorCodeHighlighterClientMissingUrlForFallback, _ErrorCodeHighlighter31);
return _createClass(ErrorCodeHighlighterClientMissingUrlForFallback);
}(ErrorCodeHighlighterClientValidation);
export var ErrorCodeHighlighterClientMissingUrlForVariants = /*#__PURE__*/function (_ErrorCodeHighlighter32) {
function ErrorCodeHighlighterClientMissingUrlForVariants() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingUrlForVariants);
return _callSuper(this, ErrorCodeHighlighterClientMissingUrlForVariants, ["Missing URL - URL is required for loading variants when no initial code is provided"]);
}
_inherits(ErrorCodeHighlighterClientMissingUrlForVariants, _ErrorCodeHighlighter32);
return _createClass(ErrorCodeHighlighterClientMissingUrlForVariants);
}(ErrorCodeHighlighterClientValidation);
export var ErrorCodeHighlighterClientMissingData = /*#__PURE__*/function (_ErrorCodeHighlighter33) {
function ErrorCodeHighlighterClientMissingData() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingData);
return _callSuper(this, ErrorCodeHighlighterClientMissingData, ["Missing data - CodeHighlighterClient requires either `variants`, `components`, or `code` to be provided."]);
}
_inherits(ErrorCodeHighlighterClientMissingData, _ErrorCodeHighlighter33);
return _createClass(ErrorCodeHighlighterClientMissingData);
}(ErrorCodeHighlighterClientValidation);
// === CONSOLE ERROR CLASSES ===
// Server console errors
export var ErrorCodeHighlighterServerLoadVariantFailure = /*#__PURE__*/function (_ErrorCodeHighlighter34) {
function ErrorCodeHighlighterServerLoadVariantFailure(url, error) {
_classCallCheck(this, ErrorCodeHighlighterServerLoadVariantFailure);
return _callSuper(this, ErrorCodeHighlighterServerLoadVariantFailure, ["Error loading variant of ".concat(url, ": ").concat(error.message)]);
}
_inherits(ErrorCodeHighlighterServerLoadVariantFailure, _ErrorCodeHighlighter34);
return _createClass(ErrorCodeHighlighterServerLoadVariantFailure);
}(ErrorCodeHighlighterServerLoader);
// Client console errors
export var ErrorCodeHighlighterClientLoadFallbackFailure = /*#__PURE__*/function (_ErrorCodeHighlighter35) {
function ErrorCodeHighlighterClientLoadFallbackFailure(error) {
_classCallCheck(this, ErrorCodeHighlighterClientLoadFallbackFailure);
return _callSuper(this, ErrorCodeHighlighterClientLoadFallbackFailure, ["Error loading fallback code: ".concat(error.message)]);
}
_inherits(ErrorCodeHighlighterClientLoadFallbackFailure, _ErrorCodeHighlighter35);
return _createClass(ErrorCodeHighlighterClientLoadFallbackFailure);
}(ErrorCodeHighlighterClientLoader);
export var ErrorCodeHighlighterClientLoadVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter36) {
function ErrorCodeHighlighterClientLoadVariantsFailure(url, errors) {
_classCallCheck(this, ErrorCodeHighlighterClientLoadVariantsFailure);
return _callSuper(this, ErrorCodeHighlighterClientLoadVariantsFailure, ["Failed to load variants:\n\n".concat(url, "\n\n").concat(errors.map(function (error) {
return error.message;
}).join('\n'))]);
}
_inherits(ErrorCodeHighlighterClientLoadVariantsFailure, _ErrorCodeHighlighter36);
return _createClass(ErrorCodeHighlighterClientLoadVariantsFailure);
}(ErrorCodeHighlighterClientLoader);
export var ErrorCodeHighlighterClientLoadAllVariantsFailure = /*#__PURE__*/function (_ErrorCodeHighlighter37) {
function ErrorCodeHighlighterClientLoadAllVariantsFailure(url, error) {
_classCallCheck(this, ErrorCodeHighlighterClientLoadAllVariantsFailure);
return _callSuper(this, ErrorCodeHighlighterClientLoadAllVariantsFailure, ["Failed to load all variants\n\n".concat(url, "\n\n").concat(error.message)]);
}
_inherits(ErrorCodeHighlighterClientLoadAllVariantsFailure, _ErrorCodeHighlighter37);
return _createClass(ErrorCodeHighlighterClientLoadAllVariantsFailure);
}(ErrorCodeHighlighterClientLoader);
export var ErrorCodeHighlighterClientMissingParseSource = /*#__PURE__*/function (_ErrorCodeHighlighter38) {
function ErrorCodeHighlighterClientMissingParseSource(url, isForceClient) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingParseSource);
var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side sourceParser or a CodeProvider for client-side parsing.';
return _callSuper(this, ErrorCodeHighlighterClientMissingParseSource, ["".concat(context, ": parseSource function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
}
_inherits(ErrorCodeHighlighterClientMissingParseSource, _ErrorCodeHighlighter38);
return _createClass(ErrorCodeHighlighterClientMissingParseSource);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingParseCode = /*#__PURE__*/function (_ErrorCodeHighlighter39) {
function ErrorCodeHighlighterClientMissingParseCode(url, isForceClient) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingParseCode);
var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side sourceParser or a CodeProvider for client-side parsing.';
return _callSuper(this, ErrorCodeHighlighterClientMissingParseCode, ["".concat(context, ": parseCode function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
}
_inherits(ErrorCodeHighlighterClientMissingParseCode, _ErrorCodeHighlighter39);
return _createClass(ErrorCodeHighlighterClientMissingParseCode);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientMissingParseControlledCode = /*#__PURE__*/function (_ErrorCodeHighlighter40) {
function ErrorCodeHighlighterClientMissingParseControlledCode(url, isForceClient) {
_classCallCheck(this, ErrorCodeHighlighterClientMissingParseControlledCode);
var context = isForceClient ? 'CodeHighlighterClient' : 'CodeHighlighter';
var details = isForceClient ? 'Make sure CodeProvider is set up correctly for client-side parsing.' : 'Code highlighting requires either server-side precomputed source or a CodeProvider for client-side parsing.';
return _callSuper(this, ErrorCodeHighlighterClientMissingParseControlledCode, ["".concat(context, ": parseControlledCode function is not available. ").concat(details).concat(url ? " (".concat(url, ")") : '')]);
}
_inherits(ErrorCodeHighlighterClientMissingParseControlledCode, _ErrorCodeHighlighter40);
return _createClass(ErrorCodeHighlighterClientMissingParseControlledCode);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientTransformProcessingFailure = /*#__PURE__*/function (_ErrorCodeHighlighter41) {
function ErrorCodeHighlighterClientTransformProcessingFailure(error) {
_classCallCheck(this, ErrorCodeHighlighterClientTransformProcessingFailure);
return _callSuper(this, ErrorCodeHighlighterClientTransformProcessingFailure, ["Failed to process transforms: ".concat(error.message)]);
}
_inherits(ErrorCodeHighlighterClientTransformProcessingFailure, _ErrorCodeHighlighter41);
return _createClass(ErrorCodeHighlighterClientTransformProcessingFailure);
}(ErrorCodeHighlighterClientLoader);
export var ErrorCodeHighlighterClientMissingLoadVariantForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter42) {
function ErrorCodeHighlighterClientMissingLoadVariantForGlobals() {
_classCallCheck(this, ErrorCodeHighlighterClientMissingLoadVariantForGlobals);
return _callSuper(this, ErrorCodeHighlighterClientMissingLoadVariantForGlobals, ["loadVariant function is required for loading missing variants in globalsCode"]);
}
_inherits(ErrorCodeHighlighterClientMissingLoadVariantForGlobals, _ErrorCodeHighlighter42);
return _createClass(ErrorCodeHighlighterClientMissingLoadVariantForGlobals);
}(ErrorCodeHighlighterClientProvider);
export var ErrorCodeHighlighterClientLoadVariantFailureForGlobals = /*#__PURE__*/function (_ErrorCodeHighlighter43) {
function ErrorCodeHighlighterClientLoadVariantFailureForGlobals(variantName, originalUrl, error) {
_classCallCheck(this, ErrorCodeHighlighterClientLoadVariantFailureForGlobals);
var url = originalUrl || 'No URL';
return _callSuper(this, ErrorCodeHighlighterClientLoadVariantFailureForGlobals, ["Failed to load variant ".concat(variantName, " for globalsCode\n\n").concat(url, "\n\n").concat((error == null ? void 0 : error.message) || 'Unknown error')]);
}
_inherits(ErrorCodeHighlighterClientLoadVariantFailureForGlobals, _ErrorCodeHighlighter43);
return _createClass(ErrorCodeHighlighterClientLoadVariantFailureForGlobals);
}(ErrorCodeHighlighterClientLoader);
export var ErrorCodeHighlighterClientLoadGlobalsCodeFailure = /*#__PURE__*/function (_ErrorCodeHighlighter44) {
function ErrorCodeHighlighterClientLoadGlobalsCodeFailure(url, error) {
_classCallCheck(this, ErrorCodeHighlighterClientLoadGlobalsCodeFailure);
return _callSuper(this, ErrorCodeHighlighterClientLoadGlobalsCodeFailure, ["Failed to load globalsCode:\n\n".concat(url || 'No URL', "\n\n").concat(error.message)]);
}
_inherits(ErrorCodeHighlighterClientLoadGlobalsCodeFailure, _ErrorCodeHighlighter44);
return _createClass(ErrorCodeHighlighterClientLoadGlobalsCodeFailure);
}(ErrorCodeHighlighterClientLoader);