mirror of
https://github.com/Sevichecc/Urara-Blog.git
synced 2025-05-06 23:19:14 +08:00
382 lines
11 KiB
Text
382 lines
11 KiB
Text
/*
|
|
Copyright 2018 Google LLC
|
|
|
|
Use of this source code is governed by an MIT-style
|
|
license that can be found in the LICENSE file or at
|
|
https://opensource.org/licenses/MIT.
|
|
*/
|
|
|
|
import '../../_version.js';
|
|
|
|
interface LoggableObject {
|
|
[key: string]: string | number;
|
|
}
|
|
interface MessageMap {
|
|
[messageID: string]: (param: LoggableObject) => string;
|
|
}
|
|
|
|
export const messages: MessageMap = {
|
|
'invalid-value': ({paramName, validValueDescription, value}) => {
|
|
if (!paramName || !validValueDescription) {
|
|
throw new Error(`Unexpected input to 'invalid-value' error.`);
|
|
}
|
|
return (
|
|
`The '${paramName}' parameter was given a value with an ` +
|
|
`unexpected value. ${validValueDescription} Received a value of ` +
|
|
`${JSON.stringify(value)}.`
|
|
);
|
|
},
|
|
|
|
'not-an-array': ({moduleName, className, funcName, paramName}) => {
|
|
if (!moduleName || !className || !funcName || !paramName) {
|
|
throw new Error(`Unexpected input to 'not-an-array' error.`);
|
|
}
|
|
return (
|
|
`The parameter '${paramName}' passed into ` +
|
|
`'${moduleName}.${className}.${funcName}()' must be an array.`
|
|
);
|
|
},
|
|
|
|
'incorrect-type': ({
|
|
expectedType,
|
|
paramName,
|
|
moduleName,
|
|
className,
|
|
funcName,
|
|
}) => {
|
|
if (!expectedType || !paramName || !moduleName || !funcName) {
|
|
throw new Error(`Unexpected input to 'incorrect-type' error.`);
|
|
}
|
|
const classNameStr = className ? `${className}.` : '';
|
|
return (
|
|
`The parameter '${paramName}' passed into ` +
|
|
`'${moduleName}.${classNameStr}` +
|
|
`${funcName}()' must be of type ${expectedType}.`
|
|
);
|
|
},
|
|
|
|
'incorrect-class': ({
|
|
expectedClassName,
|
|
paramName,
|
|
moduleName,
|
|
className,
|
|
funcName,
|
|
isReturnValueProblem,
|
|
}) => {
|
|
if (!expectedClassName || !moduleName || !funcName) {
|
|
throw new Error(`Unexpected input to 'incorrect-class' error.`);
|
|
}
|
|
const classNameStr = className ? `${className}.` : '';
|
|
if (isReturnValueProblem) {
|
|
return (
|
|
`The return value from ` +
|
|
`'${moduleName}.${classNameStr}${funcName}()' ` +
|
|
`must be an instance of class ${expectedClassName}.`
|
|
);
|
|
}
|
|
|
|
return (
|
|
`The parameter '${paramName}' passed into ` +
|
|
`'${moduleName}.${classNameStr}${funcName}()' ` +
|
|
`must be an instance of class ${expectedClassName}.`
|
|
);
|
|
},
|
|
|
|
'missing-a-method': ({
|
|
expectedMethod,
|
|
paramName,
|
|
moduleName,
|
|
className,
|
|
funcName,
|
|
}) => {
|
|
if (
|
|
!expectedMethod ||
|
|
!paramName ||
|
|
!moduleName ||
|
|
!className ||
|
|
!funcName
|
|
) {
|
|
throw new Error(`Unexpected input to 'missing-a-method' error.`);
|
|
}
|
|
return (
|
|
`${moduleName}.${className}.${funcName}() expected the ` +
|
|
`'${paramName}' parameter to expose a '${expectedMethod}' method.`
|
|
);
|
|
},
|
|
|
|
'add-to-cache-list-unexpected-type': ({entry}) => {
|
|
return (
|
|
`An unexpected entry was passed to ` +
|
|
`'workbox-precaching.PrecacheController.addToCacheList()' The entry ` +
|
|
`'${JSON.stringify(
|
|
entry,
|
|
)}' isn't supported. You must supply an array of ` +
|
|
`strings with one or more characters, objects with a url property or ` +
|
|
`Request objects.`
|
|
);
|
|
},
|
|
|
|
'add-to-cache-list-conflicting-entries': ({firstEntry, secondEntry}) => {
|
|
if (!firstEntry || !secondEntry) {
|
|
throw new Error(
|
|
`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`,
|
|
);
|
|
}
|
|
|
|
return (
|
|
`Two of the entries passed to ` +
|
|
`'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +
|
|
`${firstEntry} but different revision details. Workbox is ` +
|
|
`unable to cache and version the asset correctly. Please remove one ` +
|
|
`of the entries.`
|
|
);
|
|
},
|
|
|
|
'plugin-error-request-will-fetch': ({thrownErrorMessage}) => {
|
|
if (!thrownErrorMessage) {
|
|
throw new Error(
|
|
`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`,
|
|
);
|
|
}
|
|
|
|
return (
|
|
`An error was thrown by a plugins 'requestWillFetch()' method. ` +
|
|
`The thrown error message was: '${thrownErrorMessage}'.`
|
|
);
|
|
},
|
|
|
|
'invalid-cache-name': ({cacheNameId, value}) => {
|
|
if (!cacheNameId) {
|
|
throw new Error(
|
|
`Expected a 'cacheNameId' for error 'invalid-cache-name'`,
|
|
);
|
|
}
|
|
|
|
return (
|
|
`You must provide a name containing at least one character for ` +
|
|
`setCacheDetails({${cacheNameId}: '...'}). Received a value of ` +
|
|
`'${JSON.stringify(value)}'`
|
|
);
|
|
},
|
|
|
|
'unregister-route-but-not-found-with-method': ({method}) => {
|
|
if (!method) {
|
|
throw new Error(
|
|
`Unexpected input to ` +
|
|
`'unregister-route-but-not-found-with-method' error.`,
|
|
);
|
|
}
|
|
|
|
return (
|
|
`The route you're trying to unregister was not previously ` +
|
|
`registered for the method type '${method}'.`
|
|
);
|
|
},
|
|
|
|
'unregister-route-route-not-registered': () => {
|
|
return (
|
|
`The route you're trying to unregister was not previously ` +
|
|
`registered.`
|
|
);
|
|
},
|
|
|
|
'queue-replay-failed': ({name}) => {
|
|
return `Replaying the background sync queue '${name}' failed.`;
|
|
},
|
|
|
|
'duplicate-queue-name': ({name}) => {
|
|
return (
|
|
`The Queue name '${name}' is already being used. ` +
|
|
`All instances of backgroundSync.Queue must be given unique names.`
|
|
);
|
|
},
|
|
|
|
'expired-test-without-max-age': ({methodName, paramName}) => {
|
|
return (
|
|
`The '${methodName}()' method can only be used when the ` +
|
|
`'${paramName}' is used in the constructor.`
|
|
);
|
|
},
|
|
|
|
'unsupported-route-type': ({moduleName, className, funcName, paramName}) => {
|
|
return (
|
|
`The supplied '${paramName}' parameter was an unsupported type. ` +
|
|
`Please check the docs for ${moduleName}.${className}.${funcName} for ` +
|
|
`valid input types.`
|
|
);
|
|
},
|
|
|
|
'not-array-of-class': ({
|
|
value,
|
|
expectedClass,
|
|
moduleName,
|
|
className,
|
|
funcName,
|
|
paramName,
|
|
}) => {
|
|
return (
|
|
`The supplied '${paramName}' parameter must be an array of ` +
|
|
`'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` +
|
|
`Please check the call to ${moduleName}.${className}.${funcName}() ` +
|
|
`to fix the issue.`
|
|
);
|
|
},
|
|
|
|
'max-entries-or-age-required': ({moduleName, className, funcName}) => {
|
|
return (
|
|
`You must define either config.maxEntries or config.maxAgeSeconds` +
|
|
`in ${moduleName}.${className}.${funcName}`
|
|
);
|
|
},
|
|
|
|
'statuses-or-headers-required': ({moduleName, className, funcName}) => {
|
|
return (
|
|
`You must define either config.statuses or config.headers` +
|
|
`in ${moduleName}.${className}.${funcName}`
|
|
);
|
|
},
|
|
|
|
'invalid-string': ({moduleName, funcName, paramName}) => {
|
|
if (!paramName || !moduleName || !funcName) {
|
|
throw new Error(`Unexpected input to 'invalid-string' error.`);
|
|
}
|
|
return (
|
|
`When using strings, the '${paramName}' parameter must start with ` +
|
|
`'http' (for cross-origin matches) or '/' (for same-origin matches). ` +
|
|
`Please see the docs for ${moduleName}.${funcName}() for ` +
|
|
`more info.`
|
|
);
|
|
},
|
|
|
|
'channel-name-required': () => {
|
|
return (
|
|
`You must provide a channelName to construct a ` +
|
|
`BroadcastCacheUpdate instance.`
|
|
);
|
|
},
|
|
|
|
'invalid-responses-are-same-args': () => {
|
|
return (
|
|
`The arguments passed into responsesAreSame() appear to be ` +
|
|
`invalid. Please ensure valid Responses are used.`
|
|
);
|
|
},
|
|
|
|
'expire-custom-caches-only': () => {
|
|
return (
|
|
`You must provide a 'cacheName' property when using the ` +
|
|
`expiration plugin with a runtime caching strategy.`
|
|
);
|
|
},
|
|
|
|
'unit-must-be-bytes': ({normalizedRangeHeader}) => {
|
|
if (!normalizedRangeHeader) {
|
|
throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
|
|
}
|
|
return (
|
|
`The 'unit' portion of the Range header must be set to 'bytes'. ` +
|
|
`The Range header provided was "${normalizedRangeHeader}"`
|
|
);
|
|
},
|
|
|
|
'single-range-only': ({normalizedRangeHeader}) => {
|
|
if (!normalizedRangeHeader) {
|
|
throw new Error(`Unexpected input to 'single-range-only' error.`);
|
|
}
|
|
return (
|
|
`Multiple ranges are not supported. Please use a single start ` +
|
|
`value, and optional end value. The Range header provided was ` +
|
|
`"${normalizedRangeHeader}"`
|
|
);
|
|
},
|
|
|
|
'invalid-range-values': ({normalizedRangeHeader}) => {
|
|
if (!normalizedRangeHeader) {
|
|
throw new Error(`Unexpected input to 'invalid-range-values' error.`);
|
|
}
|
|
return (
|
|
`The Range header is missing both start and end values. At least ` +
|
|
`one of those values is needed. The Range header provided was ` +
|
|
`"${normalizedRangeHeader}"`
|
|
);
|
|
},
|
|
|
|
'no-range-header': () => {
|
|
return `No Range header was found in the Request provided.`;
|
|
},
|
|
|
|
'range-not-satisfiable': ({size, start, end}) => {
|
|
return (
|
|
`The start (${start}) and end (${end}) values in the Range are ` +
|
|
`not satisfiable by the cached response, which is ${size} bytes.`
|
|
);
|
|
},
|
|
|
|
'attempt-to-cache-non-get-request': ({url, method}) => {
|
|
return (
|
|
`Unable to cache '${url}' because it is a '${method}' request and ` +
|
|
`only 'GET' requests can be cached.`
|
|
);
|
|
},
|
|
|
|
'cache-put-with-no-response': ({url}) => {
|
|
return (
|
|
`There was an attempt to cache '${url}' but the response was not ` +
|
|
`defined.`
|
|
);
|
|
},
|
|
|
|
'no-response': ({url, error}) => {
|
|
let message = `The strategy could not generate a response for '${url}'.`;
|
|
if (error) {
|
|
message += ` The underlying error is ${error}.`;
|
|
}
|
|
return message;
|
|
},
|
|
|
|
'bad-precaching-response': ({url, status}) => {
|
|
return (
|
|
`The precaching request for '${url}' failed` +
|
|
(status ? ` with an HTTP status of ${status}.` : `.`)
|
|
);
|
|
},
|
|
|
|
'non-precached-url': ({url}) => {
|
|
return (
|
|
`createHandlerBoundToURL('${url}') was called, but that URL is ` +
|
|
`not precached. Please pass in a URL that is precached instead.`
|
|
);
|
|
},
|
|
|
|
'add-to-cache-list-conflicting-integrities': ({url}) => {
|
|
return (
|
|
`Two of the entries passed to ` +
|
|
`'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` +
|
|
`${url} with different integrity values. Please remove one of them.`
|
|
);
|
|
},
|
|
|
|
'missing-precache-entry': ({cacheName, url}) => {
|
|
return `Unable to find a precached response in ${cacheName} for ${url}.`;
|
|
},
|
|
|
|
'cross-origin-copy-response': ({origin}) => {
|
|
return (
|
|
`workbox-core.copyResponse() can only be used with same-origin ` +
|
|
`responses. It was passed a response with origin ${origin}.`
|
|
);
|
|
},
|
|
|
|
'opaque-streams-source': ({type}) => {
|
|
const message =
|
|
`One of the workbox-streams sources resulted in an ` +
|
|
`'${type}' response.`;
|
|
if (type === 'opaqueredirect') {
|
|
return (
|
|
`${message} Please do not use a navigation request that results ` +
|
|
`in a redirect as a source.`
|
|
);
|
|
}
|
|
return `${message} Please ensure your sources are CORS-enabled.`;
|
|
},
|
|
};
|