@tstdl/base 0.90.0 → 0.90.2

package/errors/errors.localization.d.ts

@@ -1,7 +1,10 @@
+import { SecretRequirementsError } from '../authentication/index.js';
+import { HttpError, HttpErrorReason } from '../http/http.error.js';
 import type { Localization, LocalizeItem } from '../text/localization.service.js';
+import { Enumeration } from '../types.js';
 import type { ApiError } from './api.error.js';
 import type { BadRequestError } from './bad-request.error.js';
-import type { CustomErrorStatic } from './custom.error.js';
+import type { CustomError, CustomErrorStatic } from './custom.error.js';
 import type { ForbiddenError } from './forbidden.error.js';
 import type { InvalidCredentialsError } from './invalid-credentials.error.js';
 import type { InvalidTokenError } from './invalid-token.error.js';
@@ -12,7 +15,18 @@ import type { NotImplementedError } from './not-implemented.error.js';
 import type { NotSupportedError } from './not-supported.error.js';
 import type { TimeoutError } from './timeout.error.js';
 import type { UnauthorizedError } from './unauthorized.error.js';
-import type { UnsupportedMediaTypeError } from './unsupported-media-type.error.js';
+type ErrorLocalizationEntry<T extends CustomError> = {
+    header: LocalizeItem<T>;
+    message?: LocalizeItem<T>;
+};
+export type ErrorsLocalizationEntries<T extends CustomErrorStatic[]> = {
+    [ErrorName in T[number]['errorName']]: ErrorLocalizationEntry<InstanceType<Extract<T[number], {
+        errorName: ErrorName;
+    }>>>;
+};
+export type ErrorsLocalization<T extends CustomErrorStatic[] = CustomErrorStatic[], Enums extends Enumeration[] = Enumeration[]> = Localization<{
+    errors: ErrorsLocalizationEntries<T>;
+}, Enums>;
 type TstdlErrors = [
     typeof ApiError,
     typeof BadRequestError,
@@ -26,19 +40,12 @@ type TstdlErrors = [
     typeof NotSupportedError,
     typeof TimeoutError,
     typeof UnauthorizedError,
-    typeof UnsupportedMediaTypeError
+    typeof HttpError,
+    typeof SecretRequirementsError
 ];
-export type ErrorsLocalizationEntries<T extends CustomErrorStatic[]> = {
-    [I in Extract<keyof T, number> as TstdlErrors[I]['errorName']]: {
-        header: LocalizeItem<InstanceType<T[I]>>;
-        message?: LocalizeItem<InstanceType<T[I]>>;
-    };
-};
-export type ErrorsLocalization<T extends CustomErrorStatic[] = CustomErrorStatic[]> = Localization<{
-    errors: ErrorsLocalizationEntries<T>;
-}>;
 export declare const errorsLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
-    errors: ErrorsLocalizationEntries<CustomErrorStatic<import("./custom.error.js").CustomError>[]>;
+    errors: ErrorsLocalizationEntries<CustomErrorStatic<CustomError>[]>;
 }>;
-export declare const germanTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors>;
+export declare const germanTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors, [typeof HttpErrorReason]>;
+export declare const englishTstdlErrorsLocalization: ErrorsLocalization<TstdlErrors>;
 export {};

package/errors/errors.localization.js

@@ -1,4 +1,6 @@
-import { getLocalizationKeys } from '../text/localization.service.js';
+import { HttpErrorReason } from '../http/http.error.js';
+import { enumerationLocalization, getLocalizationKeys } from '../text/localization.service.js';
+import { isDefined } from '../utils/type-guards.js';
 export const errorsLocalizationKeys = getLocalizationKeys();
 export const germanTstdlErrorsLocalization = {
     language: { code: 'de', name: 'Deutsch' },
@@ -21,7 +23,7 @@ export const germanTstdlErrorsLocalization = {
                 message: getErrorMessage
             },
             InvalidTokenError: {
-                header: 'Anmeldung ungültig oder abgelaufen',
+                header: 'Anmeldung abgelaufen oder ungültig',
                 message: getErrorMessage
             },
             MaxBytesExceededError: {
@@ -29,7 +31,7 @@ export const germanTstdlErrorsLocalization = {
                 message: getErrorMessage
             },
             MethodNotAllowedError: {
-                header: 'Ungültige Anfrage',
+                header: 'Anfrage nicht erlaubt',
                 message: getErrorMessage
             },
             NotFoundError: {
@@ -52,13 +54,105 @@ export const germanTstdlErrorsLocalization = {
                 header: 'Unautorisiert',
                 message: getErrorMessage
             },
-            UnsupportedMediaTypeError: {
-                header: '',
+            HttpError: {
+                header: (error) => (isDefined(error.response)
+                    ? `HTTP Fehler ${error.response.statusCode.toString()}`
+                    : 'HTTP Fehler'),
+                message: (error, context) => context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason })
+            },
+            SecretRequirementsError: {
+                header: 'Passwortanforderungen nicht erfüllt',
+                message: getErrorMessage
+            }
+        }
+    },
+    enums: [
+        enumerationLocalization(HttpErrorReason, {
+            [HttpErrorReason.Unknown]: 'Unbekannt',
+            [HttpErrorReason.Cancelled]: 'Anfrage abgebrochen',
+            [HttpErrorReason.InvalidRequest]: 'Ungültige Anfrage',
+            [HttpErrorReason.Non200StatusCode]: 'Antwort enthielt einen Fehler',
+            [HttpErrorReason.ErrorResponse]: 'Antwort enthielt einen Fehler',
+            [HttpErrorReason.ResponseError]: 'Fehler beim Empfang der Antwort',
+            [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
+        })
+    ]
+};
+export const englishTstdlErrorsLocalization = {
+    language: { code: 'en', name: 'English' },
+    keys: {
+        errors: {
+            ApiError: {
+                header: 'API error',
+                message: getErrorMessage
+            },
+            BadRequestError: {
+                header: 'Bad Request',
+                message: getErrorMessage
+            },
+            ForbiddenError: {
+                header: 'Access forbidden',
+                message: getErrorMessage
+            },
+            InvalidCredentialsError: {
+                header: 'Invalid credentials',
+                message: getErrorMessage
+            },
+            InvalidTokenError: {
+                header: 'Login expired or invalid',
+                message: getErrorMessage
+            },
+            MaxBytesExceededError: {
+                header: 'Data larger than allowed',
+                message: getErrorMessage
+            },
+            MethodNotAllowedError: {
+                header: 'Request not allowed',
+                message: getErrorMessage
+            },
+            NotFoundError: {
+                header: 'Not found',
+                message: getErrorMessage
+            },
+            NotImplementedError: {
+                header: 'Function not implemented',
+                message: getErrorMessage
+            },
+            NotSupportedError: {
+                header: 'Not supported',
+                message: getErrorMessage
+            },
+            TimeoutError: {
+                header: 'Timeout',
+                message: getErrorMessage
+            },
+            UnauthorizedError: {
+                header: 'Unauthorized',
+                message: getErrorMessage
+            },
+            HttpError: {
+                header: (error) => (isDefined(error.response)
+                    ? `HTTP error ${error.response.statusCode.toString()}`
+                    : 'HTTP error'),
+                message: (error, context) => context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason })
+            },
+            SecretRequirementsError: {
+                header: 'Secret requirements not met',
                 message: getErrorMessage
             }
         }
     },
-    enums: []
+    enums: [
+        enumerationLocalization(HttpErrorReason, {
+            [HttpErrorReason.Unknown]: 'Unknown',
+            [HttpErrorReason.Cancelled]: 'Request cancelled',
+            [HttpErrorReason.InvalidRequest]: 'Invalid request',
+            [HttpErrorReason.Non200StatusCode]: 'Response contained an error',
+            [HttpErrorReason.ErrorResponse]: 'Response contained an error',
+            [HttpErrorReason.ResponseError]: 'Error while receiving the response',
+            [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
+        })
+    ]
 };
 function getErrorMessage(error) {
     return `${error.message}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.0",
+  "version": "0.90.2",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/text/localization.service.d.ts

@@ -7,7 +7,10 @@ export type Language = {
     code: string;
     name: string;
 };
-export type LocalizeFunction<Parameters = void> = (parameters: Parameters) => string;
+export type LocalizeFunctionContext = {
+    localizationService: LocalizationService;
+};
+export type LocalizeFunction<Parameters = void> = (parameters: Parameters, context: LocalizeFunctionContext) => string;
 export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
 type LocalizationTemplate = {
     [key: string]: LocalizeItem<any> | LocalizationTemplate;

package/text/localization.service.js

@@ -163,7 +163,7 @@ let LocalizationService = class LocalizationService {
             return `__${key}__`;
         }
         if (isFunction(templateOrFunction)) {
-            return templateOrFunction(parameters);
+            return templateOrFunction(parameters, { localizationService: this });
         }
         const template = templateOrFunction;
         const templateParameters = ((isNotNull(parameters) && isObject(parameters)) ? parameters : {});