@mediusinc/mng-commons 0.0.1-rc.3 → 0.2.1-rc

package/src/lib/utils/editor-formly.util.ts

@@ -0,0 +1,193 @@
+import {FormlyFieldConfig} from '@ngx-formly/core';
+
+import {FieldLookupDescriptor,
+    EditorDescriptor,
+    FieldLookupEnumDescriptor,
+    AFieldDescriptor,
+    FieldTabGroupDescriptor,
+    FieldManyEditorDescriptor,
+    FieldManyToManyEditorDescriptor,
+    FieldInputDescriptor,
+    FieldGroupDescriptor
+} from '../descriptors';
+
+export class EditorFormlyUtil {
+    public static createFormlyConfigFromDescriptor(descriptor: EditorDescriptor<any>): FormlyFieldConfig[] {
+        const fields: FormlyFieldConfig[] = [];
+
+        if (descriptor.tabs.length === 1 && descriptor.tabs[0].default) {
+            // dont use tabs
+            fields.push(...EditorFormlyUtil.createFormlyGroupType(descriptor.tabs[0].fields));
+        } else {
+            fields.push(...EditorFormlyUtil.createFormlyTabType(descriptor.tabs));
+        }
+
+        return fields;
+    }
+
+    public static createFormlyTabType(tabGroups: FieldTabGroupDescriptor<any>[]): FormlyFieldConfig[] {
+        const tabsField: FormlyFieldConfig = {
+            type: 'tabs',
+            fieldGroup: []
+        };
+        for (const tab of tabGroups) {
+            const tabField: FormlyFieldConfig = {
+                id: tab.name,
+                templateOptions: {},
+                fieldGroup: []
+            };
+            if (tab.title) {
+                // @ts-ignore
+                tabField.templateOptions.label = tab.title;
+            }
+            // @ts-ignore
+            tabField.fieldGroup.push(...EditorFormlyUtil.createFormlyGroupType(tab.fields));
+            // @ts-ignore
+            tabsField.fieldGroup.push(tabField);
+        }
+        return [tabsField];
+    }
+
+    public static createFormlyGroupType(groups: FieldGroupDescriptor<any>[]): FormlyFieldConfig[] {
+        if (groups.length === 1 && groups[0].default) {
+            // dont use fieldset, just create fields
+            return EditorFormlyUtil.createFormlyFields(groups[0]);
+        } else {
+            const groupsField: FormlyFieldConfig = {
+                type: 'fieldset',
+                fieldGroup: []
+            };
+            for (const group of groups) {
+                const groupField: FormlyFieldConfig = {
+                    id: group.name,
+                    templateOptions: {
+                        descriptor: group
+                    },
+                    fieldGroup: []
+                };
+                if (group.title) {
+                    // @ts-ignore
+                    groupField.templateOptions.label = group.title;
+                }
+                // @ts-ignore
+                groupField.fieldGroup.push(...EditorFormlyUtil.createFormlyFields(group));
+                // @ts-ignore
+                groupsField.fieldGroup.push(groupField);
+            }
+            return [groupsField];
+        }
+    }
+
+    public static createFormlyFields(descriptor: FieldGroupDescriptor<any>): FormlyFieldConfig[] {
+        const fields: FormlyFieldConfig[] = [];
+        for (const descriptorField of descriptor.fields) {
+            fields.push(EditorFormlyUtil.createFormlyField(descriptorField));
+        }
+        // wrap in group to be able to use flex grid
+        const wrapperGroup = {
+            fieldGroupClassName: 'p-fluid formgrid grid',
+            fieldGroup: fields,
+            validators: {}
+        };
+
+        for (const validator of descriptor.validators) {
+            // @ts-ignore
+            wrapperGroup.validators[validator.name] = {expression: validator.expression, message: validator.message};
+        }
+
+        return [wrapperGroup];
+    }
+
+    public static createFormlyField(descriptor: AFieldDescriptor<any, any>): FormlyFieldConfig {
+        const field: FormlyFieldConfig = {
+            key: descriptor.property,
+            expressionProperties: {},
+            templateOptions: {},
+            validators: {}
+        };
+
+        let className = descriptor.className;
+        if (!className) {
+            // assign default field width through entire row
+            className = 'col-12';
+        }
+        if (className.indexOf('col-') < 0) {
+            // class was provided, but does not contain col- definition
+            className = `col-12 ${descriptor.className}`;
+        }
+        field.className = className;
+
+        // @ts-ignore
+        field.templateOptions.descriptor = descriptor;
+        if (descriptor instanceof FieldInputDescriptor) {
+            switch (descriptor.fieldType) {
+                case FieldInputDescriptor.TypeEnum.Textarea:
+                    field.type = 'textarea';
+                    break;
+                case FieldInputDescriptor.TypeEnum.Number:
+                    field.type = 'number';
+                    // @ts-ignore
+                    field.templateOptions.min = descriptor.numberMin;
+                    // @ts-ignore
+                    field.templateOptions.max = descriptor.numberMax;
+                    break;
+                case FieldInputDescriptor.TypeEnum.Switch:
+                    field.type = 'switch';
+                    break;
+                case FieldInputDescriptor.TypeEnum.Radio:
+                    field.type = 'radio';
+                    break;
+                case FieldInputDescriptor.TypeEnum.Datepicker:
+                    field.type = 'datepicker';
+                    break;
+                default:
+                    field.type = 'input';
+                    // @ts-ignore
+                    field.templateOptions.minLength = descriptor.minLength;
+                    // @ts-ignore
+                    field.templateOptions.maxLength = descriptor.maxLength;
+                    // @ts-ignore
+                    field.templateOptions.pattern = descriptor.pattern;
+                    break;
+            }
+        } else if (descriptor instanceof FieldLookupEnumDescriptor) {
+            field.type = 'enum';
+        } else if (descriptor instanceof FieldLookupDescriptor) {
+            switch (descriptor.lookupType) {
+                case FieldLookupDescriptor.LookupTypeEnum.Autocomplete:
+                    field.type = 'autocomplete';
+                    break;
+                case FieldLookupDescriptor.LookupTypeEnum.Dropdown:
+                default:
+                    field.type = 'dropdown';
+                    break;
+            }
+        } else if (descriptor instanceof FieldManyToManyEditorDescriptor) {
+            field.type = 'table-dialog-multiselect';
+        } else if (descriptor instanceof FieldManyEditorDescriptor) {
+            field.type = 'table-dialog-form';
+        }
+
+        if (descriptor.label) {
+            // @ts-ignore
+            field.templateOptions.label = descriptor.label;
+        }
+        if (descriptor.required) {
+            // @ts-ignore
+            field.templateOptions.required = true;
+        }
+        if (descriptor.disabled) {
+            // @ts-ignore
+            field.templateOptions.disabled = true;
+        } else {
+            // @ts-ignore
+            field.expressionProperties['templateOptions.disabled'] = 'formState.disabled';
+        }
+
+        for (const validator of descriptor.validators) {
+            field.validators[validator.name] = {expression: validator.expression, message: validator.message};
+        }
+
+        return field;
+    }
+}

package/src/lib/utils/i18n.util.ts

@@ -0,0 +1,148 @@
+import {TranslateService} from '@ngx-translate/core';
+import {Observable} from 'rxjs';
+import {first, map, mergeMap} from 'rxjs/operators';
+
+import {ActionDescriptor, ModelDescriptor} from '../descriptors';
+
+export class I18nUtil {
+
+    public static instantModelTranslation(translate: TranslateService, model: ModelDescriptor<any>, keyPath: string, customKey?: string, item?: any,
+                                           fallbackKey?: string, i18nParams?: any): string|null {
+        const keys = I18nUtil.getModelKeysByPriority(model, keyPath, customKey, fallbackKey);
+        const i18nModelName = I18nUtil.instantModelName(translate, model, true);
+        const i18n = translate.instant(keys, I18nUtil.getModelI18nParams(model, item, i18nModelName ?? undefined, i18nParams));
+        return I18nUtil.selectKeyByPriority(keys, i18n);
+    }
+
+    public static instantActionTranslation(translate: TranslateService, action: ActionDescriptor<any>, keyPath: string, customKey?: string, item?: any,
+                                           fallbackKey?: string, functionNameKey?: string, i18nParams?: any): string|null {
+        const keys = I18nUtil.getActionKeysByPriority(action, keyPath, customKey, fallbackKey);
+        const i18nModelName = I18nUtil.instantModelName(translate, action?.model, true);
+        const i18nFunctionTitle = I18nUtil.getFunctionTitle(translate, functionNameKey);
+        const i18n = translate.instant(keys, I18nUtil.getActionI18nParams(action, item, i18nModelName ?? undefined, i18nParams, i18nFunctionTitle));
+        return I18nUtil.selectKeyByPriority(keys, i18n);
+    }
+
+    public static streamActionTranslation(translate: TranslateService, action: ActionDescriptor<any>, keyPath: string, customKey?: string, item?: any, fallbackKey?: string): Observable<string|null> {
+        return I18nUtil.getActionTranslation(translate, action, keyPath, customKey, item, fallbackKey, false);
+    }
+
+    public static getActionTranslation(translate: TranslateService, action: ActionDescriptor<any>, keyPath: string, customKey?: string, item?: any, fallbackKey?: string, oneTime: boolean = true): Observable<string|null> {
+        const keys = I18nUtil.getActionKeysByPriority(action, keyPath, customKey, fallbackKey);
+        return I18nUtil.getModelName(translate, action?.model, oneTime, true).pipe(
+            mergeMap(i18nModelName => translate.get(keys, I18nUtil.getActionI18nParams(action, item, i18nModelName ?? undefined))),
+            map(i18n => I18nUtil.selectKeyByPriority(keys, i18n))
+        );
+    }
+
+    private static getModelKeysByPriority(model: ModelDescriptor<any>, keyPath: string, customKey?: string, fallbackKey?: string) {
+        const keys = [];
+        if (customKey) {
+            keys.push(customKey);
+        }
+        const modelActionKey = `${model.typeName}.${keyPath}`;
+        keys.push(modelActionKey);
+        if (fallbackKey) {
+            keys.push(fallbackKey);
+        }
+        return keys;
+    }
+
+    private static getActionKeysByPriority(action: ActionDescriptor<any>, keyPath: string, customKey?: string, fallbackKey?: string) {
+        const keys = [];
+        if (customKey) {
+            keys.push(customKey);
+        }
+        const modelActionKey = `${action.i18nModelActionBaseKey}.${keyPath}`;
+        const actionKey = `${action.actionName}.${keyPath}`;
+        keys.push(modelActionKey, actionKey);
+        if (fallbackKey) {
+            keys.push(fallbackKey);
+        }
+        return keys;
+    }
+
+    public static getModelI18nParams(model: ModelDescriptor<any>, item: any, i18nModelName?: string, i18nParameters: any = {}) {
+        i18nParameters.itemId = ''
+        i18nParameters.itemTitle = ''
+
+        if (i18nModelName) {
+            i18nParameters.modelName = i18nModelName;
+        }
+        if (item) {
+            if (model.idPropertyName && item[model.idPropertyName]) {
+                i18nParameters.itemId = item[model.idPropertyName];
+            }
+            if (model.titlePropertyName && item[model.titlePropertyName]) {
+                i18nParameters.itemTitle = item[model.titlePropertyName];
+            }
+        }
+        return i18nParameters;
+    }
+
+    public static getActionI18nParams(action: ActionDescriptor<any>, item: any, i18nModelName?: string, i18nParameters: any = {}, functionTitle?: string) {
+        i18nParameters.itemId = ''
+        i18nParameters.itemTitle = ''
+
+        if (functionTitle) {
+            i18nParameters.functionTitle = functionTitle;
+        }
+        if (i18nModelName) {
+            i18nParameters.modelName = i18nModelName;
+        }
+        if (item) {
+            if (action.model.idPropertyName && item[action.model.idPropertyName]) {
+                i18nParameters.itemId = item[action.model.idPropertyName];
+            }
+            if (action.model.titlePropertyName && item[action.model.titlePropertyName]) {
+                i18nParameters.itemTitle = item[action.model.titlePropertyName];
+            }
+        }
+        return i18nParameters;
+    }
+
+    public static instantModelName(translate: TranslateService, model: ModelDescriptor<any>, singular?: boolean): string|null {
+        const keys = I18nUtil.getModelNameKeys(model, singular);
+        const i18n = translate.instant(keys);
+        return I18nUtil.selectKeyByPriority(keys, i18n);
+    }
+
+    public static getModelName(translate: TranslateService, model: ModelDescriptor<any>, oneTime: boolean = true, singular?: boolean): Observable<string|null> {
+        const keys = I18nUtil.getModelNameKeys(model, singular);
+        const obs = translate.stream(keys);
+        if (oneTime) {
+            obs.pipe(first())
+        }
+        return obs.pipe(map(i18n => I18nUtil.selectKeyByPriority(keys, i18n)));
+    }
+
+    public static getModelNameKeys(model: ModelDescriptor<any>, singular?: boolean) {
+        let keys = [];
+        if (singular !== undefined) {
+            keys.push(singular ? `${model?.typeName}.nameSingular` : `${model?.typeName}.namePlural`);
+        }
+        keys.push(`${model?.typeName}.name`);
+        return keys;
+    }
+
+    private static selectKeyByPriority(keys: string[], i18n: any): string|null {
+        for (const key of keys) {
+            if (key !== i18n[key]) {
+                return i18n[key];
+            }
+        }
+        return null;
+    }
+
+    private static getFunctionTitle(translate: TranslateService, functionTitle?: string) {
+        if (functionTitle) {
+            const translation = translate.instant(`mngAction.functions.${functionTitle}.title`);
+            if (translation === functionTitle) {
+                return null;
+            }
+            return translation;
+        } else {
+            return null;
+        }
+    }
+}

package/{lib/utils/index.d.ts → src/lib/utils/index.ts}

@@ -1,4 +1,5 @@
-export * from './editor-formly.util';
-export * from './i18n.util';
-export * from './model.util';
-export * from './type.util';
+export * from './editor-formly.util';
+export * from './i18n.util';
+export * from './model.util';
+export * from './toast.util';
+export * from './type.util';

package/src/lib/utils/model.util.ts

@@ -0,0 +1,66 @@
+import {ClassType} from '../types';
+
+import {ObjectSerializer} from '../api/utils';
+import {ILookupDescriptor} from '../descriptors';
+
+export class ModelUtil {
+    public static findIdAttribute<T>(classType: ClassType<T>): string|null {
+        const objSerializer = ObjectSerializer.get();
+        const attributes = objSerializer.findAttributesDefinitionByClassType(classType);
+        if (!attributes) {
+            return null;
+        }
+
+        let idAttribute = attributes.find(a => a.name === 'id');
+        if (!idAttribute) {
+            // if no id, try with code
+            idAttribute = attributes.find(a => a.name === 'code');
+            if (!idAttribute) {
+                // if no id or code, take the first attribute
+                idAttribute = attributes[0];
+            }
+        }
+
+        return idAttribute?.name ?? null;
+    }
+
+    public static findTitleAttribute<T>(classType: ClassType<T>): string|null {
+        const objSerializer = ObjectSerializer.get();
+        const attributes = objSerializer.findAttributesDefinitionByClassType(classType);
+        if (!attributes) {
+            return null;
+        }
+
+        let titleAttribute = attributes.find(a => a.type === 'string' && a.name === 'name');
+        if (!titleAttribute) {
+            // if no name, try with title
+            titleAttribute = attributes.find(a => a.type === 'string' && a.name === 'title');
+            if (!titleAttribute) {
+                // if no name or title, take the first attribute
+                titleAttribute = attributes[0];
+            }
+        }
+
+        return titleAttribute?.name ?? null;
+    }
+
+    public static trySetLookupItemsProperties<T>(lookup: ILookupDescriptor<T>) {
+        if (lookup.modelType) {
+            if (!lookup.itemsValueProperty || !lookup.dataKeyProperty) {
+                const idProperty = ModelUtil.findIdAttribute(lookup.modelType) ?? undefined;
+                if (idProperty && !lookup.itemsValueProperty) {
+                    lookup.withItemsValueProperty(idProperty);
+                }
+                if (idProperty && !lookup.dataKeyProperty) {
+                    lookup.withDataKeyProperty(idProperty);
+                }
+            }
+            if (!lookup.itemsLabelProperty) {
+                const labelProperty = ModelUtil.findTitleAttribute(lookup.modelType);
+                if (labelProperty) {
+                    lookup.withItemsLabelProperty(labelProperty);
+                }
+            }
+        }
+    }
+}

package/src/lib/utils/toast.util.ts

@@ -0,0 +1,49 @@
+import {TranslateService} from '@ngx-translate/core';
+import {ActionDescriptor, TableDescriptor} from '../descriptors';
+import {TableviewComponentService} from '../components/tableview/services';
+import {I18nUtil} from './i18n.util';
+
+export class ToastUtil {
+
+    public static tableNotificationError(translationService: TranslateService, table: TableDescriptor<any>, error: any, tableview?: TableviewComponentService<any, any>) {
+        const params: any = {}
+        if (error?.message) {
+            params.errorMessage = `: ${error.message}`;
+        } else {
+            params.errorMessage = '.';
+        }
+        console.log(params)
+        const tableErrorTitle = I18nUtil.instantModelTranslation(translationService, table.model, 'table.error.title', undefined, undefined, 'general.error', params) ?? undefined;
+        const tableErrorMessage = I18nUtil.instantModelTranslation(translationService, table.model, 'table.error.message', undefined, undefined, 'general.errorMessage', params) ?? undefined;
+
+        tableview?.messageService?.add({severity: 'error', summary: tableErrorTitle, detail: tableErrorMessage});
+    }
+
+    public static actionNotificationSuccess(translationService: TranslateService, action: ActionDescriptor<any>, functionName: string, customTitleKey?: string, customMessageKey?: string, tableview?: TableviewComponentService<any, any>, item?: any) {
+        const actionSuccessTitle = I18nUtil.instantActionTranslation(translationService, action, 'success.title', customTitleKey, item, 'general.success', functionName) ?? undefined;
+        const actionSuccessMessage = I18nUtil.instantActionTranslation(translationService, action, 'success.message', customMessageKey, item, 'general.successMessage', functionName) ?? undefined;
+
+        tableview?.messageService?.add({severity: 'success', summary: actionSuccessTitle, detail: actionSuccessMessage});
+    }
+
+    public static actionNotificationError(translationService: TranslateService, action: ActionDescriptor<any>, error: any, functionName: string, tableview?: TableviewComponentService<any, any>, item?: any) {
+        const params: any = {}
+        if (error?.message) {
+            params.errorMessage = `: ${error.message}`;
+        } else {
+            params.errorMessage = '.';
+        }
+        const actionErrorTitle = I18nUtil.instantActionTranslation(translationService, action, 'error.title', action.runNotificationErrorTitle,
+            item, 'general.error', functionName, params) ?? undefined;
+        const actionErrorMessage = I18nUtil.instantActionTranslation(translationService, action, 'error.message', action.runNotificationErrorMessage,
+            item, 'general.errorMessage', functionName, params) ?? undefined;
+
+        tableview?.messageService?.add({severity: 'error', summary: actionErrorTitle, detail: actionErrorMessage});
+    }
+
+    public static getFormEditorWarningMessage(translationService: TranslateService, title: string, message: string) {
+        const actionErrorTitle = translationService.instant(title) ?? undefined;
+        const actionErrorMessage = translationService.instant(message) ?? undefined;
+        return {severity:'warn', summary: actionErrorTitle, detail: actionErrorMessage};
+    }
+}

package/src/lib/utils/type.util.ts

@@ -0,0 +1,44 @@
+import 'reflect-metadata';
+
+import {ClassType, typeNameDecoratorPropertyName} from '../types';
+
+export class TypeUtil {
+
+    public static defineReflectTypeName(targetType: ClassType<any>, typeName?: string) {
+        if (!typeName) {
+            typeName = TypeUtil.getDecoratorTypeName(targetType);
+            if (!typeName) {
+                console.warn(`Type name not provided for target ${targetType}, nor could be retrieved from decorator. Type name was not registered to reflect.`);
+                return;
+            }
+        }
+
+        if (!Reflect.hasOwnMetadata(typeNameDecoratorPropertyName, targetType)) {
+            Reflect.defineMetadata(typeNameDecoratorPropertyName, typeName, targetType);
+        }
+    }
+
+    /**
+     * Gets type name from either decorator or reflect metadata.
+     * @param type Class.
+     */
+    public static findTypeName(type: ClassType<any>): string {
+        let decoratorName = TypeUtil.getDecoratorTypeName(type);
+        if (decoratorName) {
+            return decoratorName;
+        }
+        decoratorName = Reflect.getMetadata(typeNameDecoratorPropertyName, type);
+        if (decoratorName) {
+            return decoratorName;
+        }
+        return type.name;
+    }
+
+    /**
+     * Get value from decorator defined property name
+     * @param type Class.
+     */
+    public static getDecoratorTypeName(type: Function): string|undefined {
+        return (type as any)[typeNameDecoratorPropertyName];
+    }
+}

package/{public-api.d.ts → src/public-api.ts}

@@ -1,22 +1,42 @@
-export * from './lib/mng-commons.module';
-export * from './lib/api/services';
-export * from './lib/services';
-export * from './lib/services/providers';
-export * from './lib/api/utils';
-export * from './lib/utils';
-export * from './lib/components/action';
-export * from './lib/components/form';
-export * from './lib/components/form/formly/fields';
-export * from './lib/components/form/formly/wrappers';
-export * from './lib/components/layout';
-export * from './lib/components/tableview';
-export * from './lib/directives';
-export * from './lib/pipes';
-export * from './lib/api/models';
-export * from './lib/models/config';
-export * from './lib/models/descriptors';
-export * from './lib/models/events';
-export * from './lib/models/interfaces';
-export * from './lib/models/providers';
-export * from './lib/models/types';
-export * from './lib/models/validators';
+/*
+ * Public API Surface of mng-commons
+ */
+
+// module
+export * from './lib/mng-commons.module';
+
+// services
+export * from './lib/api/services';
+export * from './lib/components/layout/services';
+export * from './lib/components/tableview/services';
+export * from './lib/services';
+export * from './lib/services/providers';
+
+// utils
+export * from './lib/api/utils';
+export * from './lib/utils';
+
+// components
+export * from './lib/components/action';
+export * from './lib/components/form';
+export * from './lib/components/form/formly/fields';
+export * from './lib/components/form/formly/wrappers';
+export * from './lib/components/layout';
+export * from './lib/components/tableview';
+
+// directives
+export * from './lib/directives';
+
+// pipes
+export * from './lib/pipes';
+
+// models&other
+export * from './lib/api/models';
+export * from './lib/components/action/models';
+export * from './lib/components/form/models';
+export * from './lib/config/models';
+export * from './lib/config';
+export * from './lib/data-providers';
+export * from './lib/descriptors';
+export * from './lib/models';
+export * from './lib/types';

package/src/test.ts

@@ -0,0 +1,26 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    keys(): string[];
+    <T>(id: string): T;
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}