@lilaquadrat/design-core 0.2.1 → 0.3.0

package/src/libs/ActionNotice.ts

@@ -19,31 +19,31 @@ export interface ErrorsObject {
 }
 
 export default class ActionNotice {
-  error: any;
+    error: any;
 
-  static parse (errors: ErrorObject[], translationPre: string | undefined, structureMappings: Record<string, string> | undefined): ErrorsObject {
+    static parse(errors: ErrorObject[], translationPre: string | undefined, structureMappings: Record<string, string> | undefined): ErrorsObject {
 
-    const parsedErrors: ErrorsObject = {};
+        const parsedErrors: ErrorsObject = {};
 
-    errors?.forEach((single) => {
+        errors?.forEach((single) => {
 
-      ActionNotice.parseSingle(single, translationPre, parsedErrors, structureMappings);
+            ActionNotice.parseSingle(single, translationPre, parsedErrors, structureMappings);
 
-    });
+        });
 
-    return parsedErrors;
+        return parsedErrors;
 
-  }
+    }
 
-  static parseSingle (error: ErrorObject, translationPre: string | undefined, errors: ErrorsObject, structureMappings: Record<string, string> | undefined) {
+    static parseSingle(error: ErrorObject, translationPre: string | undefined, errors: ErrorsObject, structureMappings: Record<string, string> | undefined) {
 
-    const pathArray = error.instancePath.split('/').filter((single) => single);
-    // check if the second element is a number, to determine if we are inside of a array
-    const arrayElementIndex = !Number.isNaN(pathArray[1]) ? +pathArray[1] + 1 : null;
-    const messageResponse = ActionNotice.getParsedError(error, pathArray[0], undefined, translationPre, structureMappings);
-    const path = messageResponse.path || pathArray[0];
+        const pathArray = error.instancePath.split('/').filter((single) => single);
+        // check if the second element is a number, to determine if we are inside of a array
+        const arrayElementIndex = !Number.isNaN(pathArray[1]) ? +pathArray[1] + 1 : null;
+        const messageResponse = ActionNotice.getParsedError(error, pathArray[0], undefined, translationPre, structureMappings);
+        const path = messageResponse.path || pathArray[0];
 
-    /**
+        /**
     pathArray has a number as second element and a element after this number
     only a numbers would mean that the array needs to have a valid element
     ```JSON
@@ -55,181 +55,181 @@ export default class ActionNotice {
     ```
     */
 
-    if (arrayElementIndex) {
+        if (arrayElementIndex) {
+
+            const arrayMessageResponse = ActionNotice.getParsedError(error, pathArray[0], pathArray[0], translationPre, structureMappings);
+            const useKey = `${pathArray[0]}-elements`;
+            const useIndex = (arrayElementIndex - 1).toString();
+            let useError = errors[useKey] as unknown as Record<string, Record<string, ParsedError>>;
 
-      const arrayMessageResponse = ActionNotice.getParsedError(error, pathArray[0], pathArray[0], translationPre, structureMappings);
-      const useKey = `${pathArray[0]}-elements`;
-      const useIndex = (arrayElementIndex - 1).toString();
-      let useError = errors[useKey] as unknown as Record<string, Record<string, ParsedError>>;
+            if (!useError) useError = {} as Record<string, Record<string, ParsedError>>;
 
-      if (!useError) useError = {} as Record<string, Record<string, ParsedError>>;
+            if (!useError[useIndex]) useError[useIndex] = {};
 
-      if (!useError[useIndex]) useError[useIndex] = {};
+            useError[useIndex][path] = arrayMessageResponse;
 
-      useError[useIndex][path] = arrayMessageResponse;
+        } else {
 
-    } else {
+            errors[path] = messageResponse;
 
-      errors[path] = messageResponse;
+        }
 
     }
 
-  }
+    static getParsedError(error: ErrorObject, usePath: string, basePath: string | undefined, translationPre: string | undefined, structureMappings: Record<string, string> | undefined): ParsedError {
 
-  static getParsedError (error: ErrorObject, usePath: string, basePath: string | undefined, translationPre: string | undefined, structureMappings: Record<string, string> | undefined): ParsedError {
+        let message: string = '';
+        let path = usePath;
+        let translatedPath: string = '';
+        const mappedErrorParams = ActionNotice.mapErrorParams(Object.values(error.params), structureMappings);
 
-    let message: string = '';
-    let path = usePath;
-    let translatedPath: string = '';
-    const mappedErrorParams = ActionNotice.mapErrorParams(Object.values(error.params), structureMappings);
+        console.log('error', mappedErrorParams);
 
-    console.log('error', mappedErrorParams);
+        console.log('error', Object.values(error.params));
 
-    console.log('error', Object.values(error.params));
+        if (error.keyword === 'type') {
 
-    if (error.keyword === 'type') {
+            message = t(
+                `validation-error-type-${error.params.type}`,
+            );
 
-      message = t(
-        `validation-error-type-${error.params.type}`,
-      );
+        }
 
-    }
+        if (error.keyword === 'minLength' || error.keyword === 'maxLength') {
 
-    if (error.keyword === 'minLength' || error.keyword === 'maxLength') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams
-      );
+        }
 
-    }
+        if (error.keyword === 'maxItems' || error.keyword === 'minItems') {
 
-    if (error.keyword === 'maxItems' || error.keyword === 'minItems') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams
-      );
+        }
 
-    }
+        if (error.keyword === 'contains') {
 
-    if (error.keyword === 'contains') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams
-      );
+        }
 
-    }
+        if (error.keyword === 'additionalProperties') {
 
-    if (error.keyword === 'additionalProperties') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams,
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams,
-      );
+            translatedPath = 'main';
 
-      translatedPath = 'main';
+        }
 
-    }
+        if (error.keyword === 'required') {
 
-    if (error.keyword === 'required') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams
-      );
+            translatedPath = '';
+            path = error.params.missingProperty;
 
-      translatedPath = '';
-      path = error.params.missingProperty;
+        }
 
-    }
+        if (error.keyword === 'enum') {
 
-    if (error.keyword === 'enum') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                [mappedErrorParams.join(',')],
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        [mappedErrorParams.join(',')],
-      );
+        }
 
-    }
+        if (error.keyword === 'invalidId') {
 
-    if (error.keyword === 'invalidId') {
+            message = t(
+                `validation-error-${error.keyword}`,
+                [error.params.invalid],
+            );
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        [error.params.invalid],
-      );
+            translatedPath = '';
+            path = error.params.invalid;
 
-      translatedPath = '';
-      path = error.params.invalid;
+        }
 
-    }
-
-    if (error.keyword === 'DOCUMENT_ALREADY_EXISTS') {
+        if (error.keyword === 'DOCUMENT_ALREADY_EXISTS') {
 
-      message = t(
-        `validation-error-${error.keyword}`,
-        mappedErrorParams
-      );
+            message = t(
+                `validation-error-${error.keyword}`,
+                mappedErrorParams
+            );
 
-      translatedPath = 'main';
-      path = 'id';
+            translatedPath = 'main';
+            path = 'id';
 
-    }
+        }
 
-    if (!message) {
+        if (!message) {
 
-      message = t(
-        `validation-error-${error.keyword}`,
-      );
-      translatedPath = 'main';
+            message = t(
+                `validation-error-${error.keyword}`,
+            );
+            translatedPath = 'main';
 
-    }
+        }
 
-    if (!translatedPath) {
+        if (!translatedPath) {
 
-      const combinedPath = basePath ? `${basePath}-${path}` : path;
+            const combinedPath = basePath ? `${basePath}-${path}` : path;
 
-      translatedPath = translationPre ? `${translationPre}-${combinedPath}` : combinedPath as string;
+            translatedPath = translationPre ? `${translationPre}-${combinedPath}` : combinedPath as string;
 
-    }
+        }
 
-    return {
-      error         : message,
-      path,
-      translatedPath: { path: translatedPath, values: Object.values(error.params) },
-      keyword       : error.keyword,
-    };
+        return {
+            error: message,
+            path,
+            translatedPath: { path: translatedPath, values: Object.values(error.params) },
+            keyword: error.keyword,
+        };
 
-  }
+    }
 
-  static reset () {
+    static reset() {
 
-    return {};
+        return {};
 
-  }
+    }
 
-  static mapErrorParams (keys: string[], mappings: Record<string, string> | undefined): string[] {
+    static mapErrorParams(keys: string[], mappings: Record<string, string> | undefined): string[] {
 
-    console.log('keys', keys, mappings);
+        console.log('keys', keys, mappings);
 
-    if (!mappings) return keys;
+        if (!mappings) return keys;
 
-    const mappedKeys = keys.map((key) => {
+        const mappedKeys = keys.map((key) => {
 
-      if (mappings[key]) {
+            if (mappings[key]) {
 
-        return mappings[key];
+                return mappings[key];
 
-      }
+            }
 
-      return key;
+            return key;
 
-    });
+        });
 
-    return mappedKeys;
+        return mappedKeys;
 
-  }
+    }
 
 }