chat4app-client-angular 0.0.1

package/README.md

@@ -0,0 +1,24 @@
+# Chat4appClientAngular
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 11.1.1.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project chat4app-client-angular` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project chat4app-client-angular`.
+> Note: Don't forget to add `--project chat4app-client-angular` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build chat4app-client-angular` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build chat4app-client-angular`, go to the dist folder `cd dist/chat4app-client-angular` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test chat4app-client-angular` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/karma.conf.js

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../coverage/chat4app-client-angular'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/chat4app-client-angular",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "chat4app-client-angular",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^11.1.1",
+    "@angular/core": "^11.1.1"
+  },
+  "dependencies": {
+    "tslib": "^2.0.0"
+  }
+}

package/src/lib/chat4app-client-angular.component.spec.ts

@@ -0,0 +1,25 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { Chat4appClientAngularComponent } from './chat4app-client-angular.component';
+
+describe('Chat4appClientAngularComponent', () => {
+  let component: Chat4appClientAngularComponent;
+  let fixture: ComponentFixture<Chat4appClientAngularComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ Chat4appClientAngularComponent ]
+    })
+    .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(Chat4appClientAngularComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/src/lib/chat4app-client-angular.component.ts

@@ -0,0 +1,20 @@
+import { Component, OnInit } from '@angular/core';
+
+@Component({
+  selector: 'lib-chat4app-client-angular',
+  template: `
+    <p>
+      chat4app-client-angular works!
+    </p>
+  `,
+  styles: [
+  ]
+})
+export class Chat4appClientAngularComponent implements OnInit {
+
+  constructor() { }
+
+  ngOnInit(): void {
+  }
+
+}

package/src/lib/chat4app-client-angular.module.ts

@@ -0,0 +1,12 @@
+import { NgModule } from '@angular/core';
+import { Chat4appClientAngularComponent } from './chat4app-client-angular.component';
+
+
+
+@NgModule({
+  declarations: [Chat4appClientAngularComponent],
+  imports: [
+  ],
+  exports: [Chat4appClientAngularComponent]
+})
+export class Chat4appClientAngularModule { }

package/src/lib/chat4app-client-angular.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { Chat4appClientAngularService } from './chat4app-client-angular.service';
+
+describe('Chat4appClientAngularService', () => {
+  let service: Chat4appClientAngularService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(Chat4appClientAngularService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/chat4app-client-angular.service.ts

@@ -0,0 +1,556 @@
+import { Injectable, OnInit } from '@angular/core';
+import * as Stomp from 'stompjs';
+import * as SockJS from 'sockjs-client';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as moment from 'moment';
+
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class Chat4appClientAngularService implements OnInit  {
+
+    chatServer = "";
+    chatUrl = "";
+    
+    sock: any;
+    stompClient: any;
+
+    constructor( private http: HttpClient) {
+  
+    }
+    ngOnInit(): void {
+    }
+
+    config(chat4AppConfig: Chat4AppConfig) {
+      this.chatServer = chat4AppConfig.endpoint;
+      this.chatUrl = chat4AppConfig.endpoint + "/api/v1/" ;
+    }
+  
+    init(callback: any, chatCallback?: IChatCallback, token?: string) {
+
+      if (!this.chatServer || this.chatServer.trim().length == 0){
+        throw new Error("Invalid endpoint");
+      }
+
+      this.getTokenChat4app().subscribe((res: any) => {
+        this.setTokenChat4app(res.token);
+  
+        if (chatCallback && token) {
+          this.connectWebsocket(chatCallback, token);
+        }
+  
+        callback(res.token);
+      })
+    }
+  
+    getChatUrlDownload(messageFileId: string) {
+      return this.chatUrl + "chatmessage/getFile?messageFileId=" + messageFileId;
+    }
+  
+  
+    getMessageChat(chatId: string, fromId: string, toId: string): Observable<Array<ChatMessage4App>> {
+      let url = this.chatUrl + "chatmessage/" + chatId + "/" + fromId + "/" + toId;
+  
+      return this.http.get<Array<ChatMessage4App>>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+  
+    }
+    getMessageChatByGrop(chatId: string, groupId: string, fromId: string): Observable<Array<ChatMessage4App>> {
+      let url = this.chatUrl + "chatmessage/byGroup/" + chatId + "/" + groupId + "/" + fromId;
+  
+      return this.http.get<Array<ChatMessage4App>>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+  
+    }
+  
+  
+    addMessageChat(chatMessage4App: ChatMessage4App): Observable<ChatMessage4App> {
+      let url = this.chatUrl + "chatmessage/" + chatMessage4App.chatId;
+  
+      return this.http.post<ChatMessage4App>(url, chatMessage4App,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+  
+    }
+    props(chatFilterRequest4App: Array<ChatFilterRequest4App>): Observable<ChatUserResponse4App> {
+      let url = this.chatUrl + "chatmessage/props";
+  
+      return this.http.post<ChatUserResponse4App>(url, chatFilterRequest4App,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+  
+    }
+  
+  
+    removeUsersChat(chatId: string, chatUsersId?: string[], chatUsersExternalId?: string[]): Observable<ChatUser4App[]> {
+      let params = new Array();
+      if (chatUsersId && chatUsersId.length > 0) {
+  
+        chatUsersId.forEach(cui => {
+          params.push("chatUserId=" + cui);
+        });
+      } else if (chatUsersExternalId && chatUsersExternalId.length > 0) {
+        chatUsersExternalId.forEach(cuei => {
+          params.push("chatUserExternalId=" + cuei);
+        })
+  
+      }
+  
+      let url = this.chatUrl + "chatuser/" + chatId + "?" + params.join("&");
+  
+      return this.http.delete<ChatUser4App[]>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+    removeUserChat(chatId: string, chatUserId?: string, chatUserExternalId?: string): Observable<ChatUser4App> {
+      let param = "";
+      if (chatUserId) {
+        param = "chatUserId=" + chatUserId;
+      } else {
+        param = "chatUserExternalId=" + chatUserExternalId;
+      }
+  
+      let url = this.chatUrl + "chatuser/" + chatId + "?" + param;
+  
+      return this.http.delete<ChatUser4App>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+    updateUserChat(chatId: string, charUser4AppUpdate: ChatUser4App): Observable<ChatUser4App> {
+  
+      let url = this.chatUrl + "chatuser/" + chatId;
+  
+      return this.http.put<ChatUser4App>(url, charUser4AppUpdate,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+  
+    createUserChat(chatId: string, chatUser4App: ChatUser4App): Observable<ChatUser4App> {
+      let url = this.chatUrl + "chatuser/" + chatId;
+  
+      return this.http.post<ChatUser4App>(url, chatUser4App,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+    createUsersChat(chatId: string, chatUser4App: ChatUser4App[]): Observable<ChatUser4App[]> {
+      let url = this.chatUrl + "chatuser/users/" + chatId;
+  
+      return this.http.post<ChatUser4App[]>(url, chatUser4App,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+  
+    createChat(chat4app: Chat4App): Observable<Chat4App> {
+      let url = this.chatUrl + "chat";
+  
+      return this.http.post<Chat4App>(url, chat4app,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+    createUpdateChat(chat4app: Chat4App): Observable<Chat4App> {
+      let url = this.chatUrl + "chat";
+  
+      return this.http.put<Chat4App>(url, chat4app,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+  
+    getLastMessageGroup(chatExternalId: string, groupId: string): Observable<ChatUserResponse4App> {
+  
+      let url = this.chatUrl + "chatmessage/lastMessageGroup?chatExternalId=" + chatExternalId + "&groupId=" + groupId;
+  
+      return this.http.get<ChatUserResponse4App>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+    getLastMessage(chatExternalId: string, chatUserExternalId: string): Observable<ChatUserResponse4App> {
+  
+      let url = this.chatUrl + "chatmessage/lastMessage?chatExternalId=" + chatExternalId + "&chatUserExternalId=" + chatUserExternalId;
+  
+      return this.http.get<ChatUserResponse4App>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+    countNotReadMessages(chatUserExternalId: string, chatExternalId?: string, groupId?: string): Observable<ChatUserResponse4App> {
+  
+      let url = this.chatUrl + "chatmessage/countNotReadMessages?chatUserExternalId=" + chatUserExternalId;
+  
+      if (chatExternalId && chatExternalId.length > 0) {
+        url += "&chatExternalId=" + chatExternalId;
+      }
+  
+      if (groupId && groupId.length > 0) {
+        url += "&groupId=" + groupId;
+      }
+  
+      return this.http.get<ChatUserResponse4App>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+  
+    getChatByExternalId(externalId: string): Observable<Chat4App> {
+  
+      let url = this.chatUrl + "chat?externalId=" + externalId;
+  
+      return this.http.get<Chat4App>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+    readMessage(chatMessageId: string, toId?: string): Observable<void> {
+  
+      let url = this.chatUrl + "chatmessage/read/" + chatMessageId;
+  
+      if (toId && toId.length > 0) {
+        url += "/" + toId;
+      }
+  
+      return this.http.put<void>(url, null,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+    online(chatId: string, chatUserId: string): Observable<number> {
+  
+      let url = this.chatUrl + "chatmessage/online/" + chatId + "/" + chatUserId;
+  
+      return this.http.get<number>(url,
+        {
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+        })
+    }
+  
+  
+    sendFile(chatId: string, fromId: string, toId: string, fileToUpload: File): Observable<ChatMessageFile4App> {
+      const endpoint = this.chatUrl + "chatmessage/sendFile/" + chatId + "/" + fromId + "/" + toId;
+  
+      const formData: FormData = new FormData();
+      formData.append('file', fileToUpload);
+  
+      return this.http
+        .post<ChatMessageFile4App>(endpoint, formData,
+          {
+            headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+          });
+    }
+  
+    sendFileGroup(chatId: string, fromId: string, groupId: string, fileToUpload: File): Observable<ChatMessageFile4App> {
+      const endpoint = this.chatUrl + "chatmessage/sendFileGroup/" + chatId + "/" + fromId + "/" + groupId;
+  
+      const formData: FormData = new FormData();
+      formData.append('file', fileToUpload);
+  
+      return this.http
+        .post<ChatMessageFile4App>(endpoint, formData,
+          {
+            headers: new HttpHeaders().set('Authorization', this.getBearerToken())
+          });
+    }
+  
+  
+    /* Token */
+    getBearerToken(): string {
+  
+      let ret = "Bearer " + window.sessionStorage.getItem("chat4AppSessionToken");
+  
+      return ret;
+    }
+  
+    getTokenChat4app() {
+      return this.http.post("/rest/secured/chat-helper", null);
+    }
+  
+    setTokenChat4app(chat4AppSessionToken: string) {
+  
+  
+      window.sessionStorage.setItem("chat4AppSessionToken", chat4AppSessionToken);
+    }
+  
+  
+    /* Connection */
+  
+    onMessageFirebaseReceived(data: any, chatCallback: IChatCallback) {
+  
+  
+      //alert("onMessageReceived connectFirebase");
+  
+      if (data.type == "msg") {
+  
+        let chat4appMessage = new Chat4AppMessageReceive();
+        chat4appMessage.data.chatId = data.chatId;
+        chat4appMessage.data.chatMessageId = data.chatMessageId;
+        chat4appMessage.data.externalId = data.externalId;
+        chat4appMessage.data.fromId = data.fromId;
+        chat4appMessage.data.toId = data.toId;
+        chat4appMessage.data.dateHour = data.dateHour;
+        chat4appMessage.data.type = data.type;
+        chat4appMessage.notification.body = data.body;
+  
+        if (data.fileId && data.fileId.length > 0) {
+          chat4appMessage.data.fileId = data.fileId;
+          chat4appMessage.data.fileName = data.fileName;
+          chat4appMessage.data.fileSize = data.fileSize;
+          chat4appMessage.data.fileType = data.fileType;
+  
+        }
+  
+        let datTmp = new Map<string, string>();
+  
+        for (let key in data) {
+          datTmp.set(key, data[key]);
+        }
+  
+        chat4appMessage.data.all = datTmp;
+  
+        chatCallback.onMessage(chat4appMessage);
+  
+      } else if ((data.type == "on" || data.type == "off")) {
+        let chat4appMessage = new Chat4AppMessageReceive();
+        chat4appMessage.data.chatId = data.chatId;
+        chat4appMessage.data.chatMessageId = data.chatMessageId;
+        chat4appMessage.data.externalId = data.externalId;
+        chat4appMessage.data.fromId = data.fromId;
+        chat4appMessage.data.toId = data.toId;
+        chat4appMessage.data.dateHour = data.dateHour;
+        chat4appMessage.data.type = data.type;
+
+        let datTmp = new Map<string, string>();
+  
+        for (let key in data) {
+          datTmp.set(key, data[key]);
+        }
+  
+        chat4appMessage.data.all = datTmp;
+  
+        chatCallback.onOffline(chat4appMessage);
+    
+      }
+    }
+  
+    connectWebsocket(chatCallback: IChatCallback, token: string) {
+      this.disconnect();
+  
+      let securityToken = this.getBearerToken();
+  
+      this.sock = new SockJS(this.chatServer + '/stomp/gkz-stomp-endpoint?token=' + securityToken);
+      this.stompClient = Stomp.over(this.sock);
+      this.stompClient.debug = function (msg: any) {
+        //console.log(msg);
+      }
+  
+      this.stompClient.connect({}, (frame: any) => {
+        //console.log(frame);
+  
+        this.stompClient.subscribe('/queue/' + token, (msg: any) => {
+          //console.log('mensagem', msg);
+  
+          if (msg.command == "MESSAGE") {
+  
+            //console.log(msg)
+  
+            let msgObj = JSON.parse(msg.body);
+  
+            let datTmp = new Map<string, string>();
+  
+            for (let key in msgObj.data) {
+              datTmp.set(key, msgObj.data[key]);
+            }
+  
+            msgObj.data.all = datTmp;
+  
+            if (msgObj.data.type == "msg") {
+              chatCallback.onMessage(msgObj);
+            } else if ((msgObj.data.type == "on" || msgObj.data.type == "off")) {
+              chatCallback.onOffline(msgObj);
+            }
+            
+            //callback(msg.body);
+            // ichatcallback.forEach((iChat)=>{
+            //   iChat.onMessage(JSON.parse(msg.body) );
+            // });
+          }
+  
+        });
+      },
+        (message: any) => {
+          // check message for disconnect
+          //console.log("Disconnect");
+  
+          setTimeout(() => {
+            this.connectWebsocket(chatCallback, token);
+          }, 500);
+  
+        });
+  
+    }
+  
+    disconnect() {
+//      console.log("disconnect")
+      try {
+        if (this.stompClient) {
+          this.stompClient.disconnect();
+        }
+  
+      } catch (e) {
+        console.log(e);
+      }
+    }
+
+    convertChat4AppMessageReceiveToChatMessage4App(msg: Chat4AppMessageReceive): ChatMessage4App{
+      let message = new ChatMessage4App();
+      message.body = msg.notification.body;
+      message.chatId = msg.data.chatId;
+      message.fromId = msg.data.fromId;
+      message.toId = msg.data.toId;
+      message.dateHourIncluded = moment.utc(msg.data.dateHour, "DD-MM-YYYY hh:mm:ss").toDate();
+
+      if (msg.data.fileId && msg.data.fileId.length > 0) {
+        let messageFile = new ChatMessageFile4App();
+        
+        messageFile.id = msg.data.fileId;
+        messageFile.name = msg.data.fileName;
+        messageFile.size = msg.data.fileSize;
+        messageFile.type = msg.data.fileType;
+
+        message.chatMessageFile = messageFile;
+      }
+
+      return message;
+
+    }
+  
+  }
+  
+  
+  export class Chat4App {
+    id: string;
+    configId: string;
+    externalId: string;
+    title: string;
+    status: ChatStatus4App;
+    users: Array<ChatUser4App>;
+  
+  }
+  export class ChatUser4App {
+    id: string;
+    name: string;
+    clientToken: string;
+    picturePath: string;
+    email: string;
+    externalId: string;
+    status: ChatUserStatus4App;
+  }
+  export class ChatMessage4App {
+    id: string;
+    fromId: string;
+    toId: string;
+    chatId: string;
+    title: string;
+    body: string;
+    meta: Array<ChatMessageMeta4App>;
+    groupId: string;
+    read: Boolean;
+    dateHourIncluded: Date;
+    chatMessageFile: ChatMessageFile4App;
+  }
+  export class ChatMessageFile4App {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    fullPath: string;
+  }
+  export class ChatMessageMeta4App {
+    name: string;
+    value: string;
+  }
+  export class Chat4AppMessageReceive {
+    data: Chat4AppMessageReceiveData = new Chat4AppMessageReceiveData();
+    notification: Chat4AppMessageReceiveNotification = new Chat4AppMessageReceiveNotification();
+    token: string;
+  }
+  export class Chat4AppMessageReceiveData {
+    toId: string;
+    chatId: string;
+    dateHour: string;
+    chatMessageId: string;
+    externalId: string;
+    type: string;
+    fromId: string;
+    fileId: string;
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    all: Map<string, string>;
+  
+  
+  
+  }
+  export class Chat4AppMessageReceiveNotification {
+    body: string;
+  }
+  
+  export class ChatUserResponse4App {
+    totalMessages: number;
+    chat: Chat4App;
+    chatMessage: ChatMessage4App;
+    chats: ChatUserResponse4App[];
+  }
+  export class ChatFilterRequest4App {
+    type: ChatFilterType;
+    chatExternalId: string;
+    chatUserExternalId: string;
+    groupId: string;
+  }
+  export class Chat4AppConfig {
+    constructor(public endpoint: string) {
+      
+    }
+  }
+
+  
+  export enum ChatStatus4App {
+    CREATED = "CREATED",
+    CLOSED = "CLOSED"
+  
+  }
+  export enum ChatUserStatus4App {
+    REMOVED = "REMOVED"
+  
+  }
+  export enum ChatFilterType {
+    COUNT_NOT_READ = 1,
+    LAST_MESSAGE = 2
+  }
+  
+  export interface IChatCallback {
+    onMessage(msg: Chat4AppMessageReceive): void;
+    onOffline(msg: Chat4AppMessageReceive): void;
+  }
+  

package/src/public-api.ts

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of chat4app-client-angular
+ */
+
+export * from './lib/chat4app-client-angular.service';
+export * from './lib/chat4app-client-angular.component';
+export * from './lib/chat4app-client-angular.module';

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/dist/zone';
+import 'zone.js/dist/zone-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,26 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "target": "es2015",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": [],
+    "lib": [
+      "dom",
+      "es2018"
+    ]
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+    "enableIvy": false
+  },
+  "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": {
+    "enableIvy": false
+  }
+}

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"
+  ]
+}

package/tslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tslint.json",
+  "rules": {
+    "directive-selector": [
+      true,
+      "attribute",
+      "lib",
+      "camelCase"
+    ],
+    "component-selector": [
+      true,
+      "element",
+      "lib",
+      "kebab-case"
+    ]
+  }
+}