@lilaquadrat/design-core 0.1.0

package/src/interfaces/GenericEvents.interface.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+
+export default interface GenericEvents {
+    // eslint-disable-next-line no-unused-vars
+    [key: string]: (additionalData: string | undefined, mouseEvent: MouseEvent, traceId: Ref) => void;
+}

package/src/interfaces/GenericState.interface.ts

@@ -0,0 +1,5 @@
+import type { ModuleGeneric } from '@lilaquadrat/interfaces';
+
+export default interface GenericState {
+  [key: string]: {[key: string]: string | string[]} | number | boolean | string | string[] | ModuleGeneric[] | Date | any;
+}

package/src/interfaces/IconsPartial.ts

@@ -0,0 +1,9 @@
+export default interface IconsPartial {
+    type: 'arrow-right' | 'arrow-left' | 'arrow-right-long' | 'chevron-down' | 'chevron-up' | 'chevron-left' | 'chevron-right' 
+    | 'mouse' | 'checked' | 'close' | 'zoom-in' | 'zoom-out' | 'warning' | 'location' | 'play' | 'pause' | 'muted' | 'unmuted' | 'calendar' | 'cart'
+    | 'image' | 'document' | 'trash' | 'download' | 'replay'
+    colorScheme?: 'colorScheme1' | 'colorScheme2' | 'colorScheme4' |'white' | 'grey' | 'red' | 'bright' | 'dark' | 'textColor'
+    size?: 'small' | 'smaller' | 'medium' | 'large' | 'larger' | 'big' | 'xl'
+    rotate?: number
+    animate?: boolean
+  }

package/src/interfaces/IdTokenExtended.interface.ts

@@ -0,0 +1,7 @@
+import type { IdToken } from '@auth0/auth0-spa-js';
+
+export default interface IdTokenExtended extends IdToken {
+    lilaquadrat_configuration?: boolean
+    lilaquadrat_firstLogin?: boolean
+}
+

package/src/interfaces/ModuleBaseProps.interface.ts

@@ -0,0 +1,8 @@
+export default interface ModuleBaseProps {
+    sub?: boolean
+    id?: string
+    parentId: string
+    uuid: string
+    variant?: string[]
+    index?: {title?: string, anchor?: string}
+}

package/src/interfaces/PaymentProvider.interface.ts

@@ -0,0 +1,13 @@
+export default interface PaymentProvider {
+
+    getCart(attributes?: Record<string, string>): Promise<{id: string, checkourUrl?: string}>;
+    updateCartAttributes(cartId: string, attributes?: Record<string, string>): Promise<{id: string, checkourUrl?: string}>;
+    getCartWithProducts(cartId: string): Promise<any[]>;
+    getProduct(productId: string): Promise<any>;
+    addToCart(cartId: string, product: any, amount: number): Promise<any>;
+    removeFromCart(cartId: string, product: any): Promise<any>;
+    updateQuantity(cartId: string, cartProduct: any, amount: number): Promise<any>;
+    finalize(cartId: string): Promise<any>;
+    getFinishedCart(cartId: string): Promise<any>;
+
+}

package/src/libs/ActionNotice.ts

@@ -0,0 +1,235 @@
+import { t } from '../plugins/translations';
+import type { ErrorObject } from 'ajv';
+
+export interface TranslatedPath {
+  path?: string,
+  values?: string[]|number[]
+}
+
+export interface ParsedError {
+    path: string
+    translatedPath: TranslatedPath
+    parentPath?: TranslatedPath
+    error: string
+    keyword: string
+}
+
+export interface ErrorsObject {
+  [key: string]: ParsedError
+}
+
+export default class ActionNotice {
+  error: any;
+
+  static parse (errors: ErrorObject[], translationPre: string | undefined, structureMappings: Record<string, string> | undefined): ErrorsObject {
+
+    const parsedErrors: ErrorsObject = {};
+
+    errors?.forEach((single) => {
+
+      ActionNotice.parseSingle(single, translationPre, parsedErrors, structureMappings);
+
+    });
+
+    return parsedErrors;
+
+  }
+
+  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];
+
+    /**
+    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
+    {
+      instancePath: "/categories/0",
+      schemaPath: "#/properties/categories/items/required",
+      keyword: "required"
+    }
+    ```
+    */
+
+    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>>;
+
+      if (!useError) useError = {} as Record<string, Record<string, ParsedError>>;
+
+      if (!useError[useIndex]) useError[useIndex] = {};
+
+      useError[useIndex][path] = arrayMessageResponse;
+
+    } else {
+
+      errors[path] = messageResponse;
+
+    }
+
+  }
+
+  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);
+
+    console.log('error', mappedErrorParams);
+
+    console.log('error', Object.values(error.params));
+
+    if (error.keyword === 'type') {
+
+      message = t(
+        `validation-error-type-${error.params.type}`,
+      );
+
+    }
+
+    if (error.keyword === 'minLength' || error.keyword === 'maxLength') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams
+      );
+
+    }
+
+    if (error.keyword === 'maxItems' || error.keyword === 'minItems') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams
+      );
+
+    }
+
+    if (error.keyword === 'contains') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams
+      );
+
+    }
+
+    if (error.keyword === 'additionalProperties') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams,
+      );
+
+      translatedPath = 'main';
+
+    }
+
+    if (error.keyword === 'required') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams
+      );
+
+      translatedPath = '';
+      path = error.params.missingProperty;
+
+    }
+
+    if (error.keyword === 'enum') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        [mappedErrorParams.join(',')],
+      );
+
+    }
+
+    if (error.keyword === 'invalidId') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        [error.params.invalid],
+      );
+
+      translatedPath = '';
+      path = error.params.invalid;
+
+    }
+
+    if (error.keyword === 'DOCUMENT_ALREADY_EXISTS') {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+        mappedErrorParams
+      );
+
+      translatedPath = 'main';
+      path = 'id';
+
+    }
+
+    if (!message) {
+
+      message = t(
+        `validation-error-${error.keyword}`,
+      );
+      translatedPath = 'main';
+
+    }
+
+    if (!translatedPath) {
+
+      const combinedPath = basePath ? `${basePath}-${path}` : path;
+
+      translatedPath = translationPre ? `${translationPre}-${combinedPath}` : combinedPath as string;
+
+    }
+
+    return {
+      error         : message,
+      path,
+      translatedPath: { path: translatedPath, values: Object.values(error.params) },
+      keyword       : error.keyword,
+    };
+
+  }
+
+  static reset () {
+
+    return {};
+
+  }
+
+  static mapErrorParams (keys: string[], mappings: Record<string, string> | undefined): string[] {
+
+    console.log('keys', keys, mappings);
+
+    if (!mappings) return keys;
+
+    const mappedKeys = keys.map((key) => {
+
+      if (mappings[key]) {
+
+        return mappings[key];
+
+      }
+
+      return key;
+
+    });
+
+    return mappedKeys;
+
+  }
+
+}