@mtgame/core 0.2.25 → 2.0.0

package/services/base.controller.d.ts

@@ -0,0 +1,12 @@
+import { Observable, Subject } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { Storage } from '../storage/new';
+export declare type ComponentType = any & OnDestroy;
+export declare abstract class BaseController<T> {
+    protected abstract store: Storage<T>;
+    protected destroyed$: Subject<unknown>;
+    storeData$<K extends keyof T>(keys: K[]): Observable<{
+        [P in K]: T[P];
+    }>;
+    dispose(clearData?: boolean): void;
+}

package/services/base.service.d.ts

@@ -1,5 +1,8 @@
 import { Store } from '../storage/store';
+import * as i0 from "@angular/core";
 export declare class BaseService {
     protected store: Store;
     dispose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseService>;
 }

package/services/centrifugo.service.d.ts

@@ -1,23 +1,25 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { ConfigService } from './config.service';
+import * as i0 from "@angular/core";
 export declare class CentrifugoService {
     private httpClient;
     private configService;
-    private platformId;
     private channels$;
     private subscriptions;
     private centrifuge;
     private initializeEngineSubject;
     private connectedSubject;
     get connected$(): Observable<boolean>;
-    constructor(httpClient: HttpClient, configService: ConfigService, platformId: string);
-    listen<T = any>(channel: any): Observable<T>;
+    constructor(httpClient: HttpClient, configService: ConfigService);
+    listen<T>(channel: any): Observable<T>;
     unsubscribe(channel: any): void;
     connect(): Observable<boolean>;
-    publish(channel: string, message: any): Observable<any>;
+    publish(channel: string, message: any): Promise<any>;
     disconnect(): void;
     private initializeEngine;
     private addEngineSubscription;
     private resolveMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CentrifugoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CentrifugoService>;
 }

package/services/config.service.d.ts

@@ -1,4 +1,5 @@
 import { BaseService } from './base.service';
+import * as i0 from "@angular/core";
 export declare const CONFIG_DATA = "mtg-core-config-data";
 export declare class ConfigService extends BaseService {
     private configData;
@@ -8,4 +9,6 @@ export declare class ConfigService extends BaseService {
     initialize(data: any): void;
     set(key: string, value: any): void;
     get(key: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
 }

package/services/public-api.d.ts

@@ -1,3 +1,4 @@
 export { BaseService } from './base.service';
 export { CentrifugoService } from './centrifugo.service';
 export { ConfigService, CONFIG_DATA } from './config.service';
+export * from './base.controller';

package/storage/local-storage-engine.d.ts

@@ -1,5 +1,5 @@
-import { StorageEngine } from './storage-engine';
-export declare class LocalStorageEngine extends StorageEngine {
+import { StorageEngine, StorageEngineData } from './storage-engine';
+export declare class LocalStorageEngine<T extends StorageEngineData> extends StorageEngine<T> {
     protected setItem(key: string, value: any): void;
     protected getItem(key: string): any;
     protected removeItem(key: string): void;

package/storage/new.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { StorageEngine } from './storage-engine';
+export declare class Storage<T> {
+    private readonly initial;
+    private readonly subject;
+    protected readonly engine: StorageEngine<Partial<T>>;
+    get data$(): Observable<T>;
+    byKey$<K extends keyof T>(key: K): Observable<T[K]>;
+    byKeys$<K extends keyof T>(keys: K[]): Observable<{
+        [P in K]: T[P];
+    }>;
+    get data(): T;
+    constructor(initial: Required<T>, engine?: StorageEngine<Partial<T>>);
+    update(data: Partial<T>): void;
+    reset(): void;
+    mergeWith<M>(data$: Observable<M>, mapper: (M: any) => Partial<T>): this;
+}

package/storage/old-local-storage-engine.d.ts

@@ -0,0 +1,6 @@
+import { OldStorageEngine } from './old-storage-engine';
+export declare class OldLocalStorageEngine<T> extends OldStorageEngine<T> {
+    protected setItem(key: string, value: any): void;
+    protected getItem(key: string): any;
+    protected removeItem(key: string): void;
+}

package/storage/old-storage-engine.d.ts

@@ -0,0 +1,24 @@
+import { ModelRelation } from '../models/util';
+export declare class OldStorageEngineField<T> {
+    protected model?: ModelRelation<T>;
+    defaultValue: any;
+    constructor(defaultValue?: any, model?: ModelRelation<T>);
+    create(value: any): T;
+    json(value: T): any;
+}
+export declare abstract class OldStorageEngine<T> {
+    protected name: string;
+    protected fields: {
+        [Property in keyof T]: OldStorageEngineField<T[Property]>;
+    };
+    constructor(name: string, fields: {
+        [Property in keyof T]: OldStorageEngineField<T[Property]>;
+    });
+    addField(key: keyof T, field: OldStorageEngineField<T[typeof key]>): void;
+    save(key: keyof T, value: T[typeof key]): void;
+    get(key: keyof T): T[typeof key];
+    clear(): void;
+    protected abstract getItem(key: string): any;
+    protected abstract setItem(key: string, value: any): any;
+    protected abstract removeItem(key: string): any;
+}

package/storage/public-api.d.ts

@@ -1,3 +1,6 @@
-export * from './local-storage-engine';
-export * from './storage-engine';
+export * from './old-local-storage-engine';
+export * from './old-storage-engine';
 export * from './store';
+export * from './new';
+export * from './storage-engine';
+export * from './local-storage-engine';

package/storage/storage-engine.d.ts

@@ -1,24 +1,31 @@
-import { ModelInterface } from '../models/util';
-export declare class StorageEngineField {
-    protected modelClass?: ModelInterface;
-    defaultValue: any;
-    constructor(defaultValue?: any, modelClass?: ModelInterface);
-    toFront(value: any): any;
-    toBack(value: any): any;
+import { BaseModel, ModelRelation } from '../models/util';
+export declare type StorageEngineType = number | string | boolean | number[] | string[] | BaseModel | BaseModel[] | {
+    [key: string]: any;
+} | {
+    [key: string]: any;
+}[];
+export declare type StorageEngineData = {
+    [key: string]: any;
+};
+export declare class StorageEngineField<T extends StorageEngineType> {
+    protected model?: ModelRelation<T>;
+    constructor(model?: ModelRelation<T>);
+    create(value: any): T;
+    json(value: T): any;
 }
-export declare abstract class StorageEngine {
-    protected name: string;
-    protected fields: {
-        [key: string]: StorageEngineField;
+export declare abstract class StorageEngine<T extends StorageEngineData> {
+    protected readonly name: string;
+    protected readonly fields: {
+        [Property in keyof T]: StorageEngineField<T[Property]>;
     };
     constructor(name: string, fields: {
-        [key: string]: StorageEngineField;
+        [Property in keyof T]: StorageEngineField<T[Property]>;
     });
-    addField(key: string, field: StorageEngineField): void;
-    save(key: string, value: any): void;
-    get(key: string): any;
+    save(value: Partial<T>): void;
+    getValue<K extends keyof T>(key: K): T[K];
+    getAll(): T;
     clear(): void;
-    protected getItem(key: string): any;
-    protected setItem(key: string, value: any): any;
-    protected removeItem(key: string): void;
+    protected abstract getItem(key: string): any;
+    protected abstract setItem(key: string, value: any): any;
+    protected abstract removeItem(key: string): any;
 }

package/storage/store.d.ts

@@ -1,9 +1,9 @@
 import { Observable } from 'rxjs';
-import { StorageEngine } from './storage-engine';
+import { OldStorageEngine } from './old-storage-engine';
 export declare class Store {
     private engine?;
     private data;
-    constructor(engine?: StorageEngine);
+    constructor(engine?: OldStorageEngine<any>);
     get(key: string, defaultValue?: any): Observable<any>;
     value(key: string, defaultValue?: any): any;
     save(key: string, value: any): void;
@@ -16,6 +16,6 @@ export declare class Store {
     deleteItem(key: string, value: any): void;
     dispose(): void;
     clearStorageData(): void;
-    getEngine(): StorageEngine;
+    getEngine(): OldStorageEngine<any>;
     private getSubject;
 }

package/utils/component-destroyed.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/internal/Observable';
+import { Observable } from 'rxjs';
 export interface OnDestroyLike {
     ngOnDestroy(): void;
     [key: string]: any;

package/utils/data.d.ts

@@ -1,6 +1,36 @@
-export declare function updateItemInArray(data: any[], item: any, force?: boolean, checkFunction?: (item: any) => boolean): any[];
-export declare function updateItemsInArray(data: any[], items: any[], force?: boolean, checkFunction?: (item: any) => boolean): any[];
-export declare function patchItemInArray(data: any[], item: any, checkFunction?: (item: any) => boolean): any[];
-export declare function addItemInArray(data: any[], item: any, atEnd?: boolean, checkFunction?: (item: any) => boolean): any[];
-export declare function addItemsInArray(data: any[], items: any[], atEnd?: boolean, checkFunction?: (item: any) => boolean): any[];
-export declare function deleteItemFromArray(data: any[], item: any): any[];
+import { BaseModel } from '../models/util';
+declare class BaseModelWithId extends BaseModel {
+    id: number;
+}
+declare class BaseModelWithUpdatedAt extends BaseModelWithId {
+    updatedAt: Date;
+}
+declare type Model = BaseModelWithId | BaseModelWithUpdatedAt;
+declare type checkFunctionType<T> = (item: T) => boolean;
+declare type MappedModel<T> = {
+    [key: string]: T;
+};
+declare type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+export declare function updateItemInArray<T extends Model>(data: T[], item: T, force?: boolean, checkFunction?: checkFunctionType<T>): T[];
+export declare function updateItemsInArray<T extends Model>(data: T[], items: T[], force?: boolean, checkFunction?: checkFunctionType<T>): T[];
+export declare function patchItemInArray<T extends Model>(data: T[], item: T, checkFunction?: checkFunctionType<T>): T[];
+export declare function addItemInArray<T extends Model>(data: T[], item: T, atEnd?: boolean, checkFunction?: checkFunctionType<T>): T[];
+export declare function addItemsInArray<T extends Model>(data: T[], items: T[], atEnd?: boolean, checkFunction?: (item: T) => boolean): T[];
+export declare function deleteItemFromArray<T extends Model>(data: T[], item: T | checkFunctionType<T>): T[];
+export declare const _: {
+    insert: <T extends Model>(data: T[], item: T, atEnd?: boolean, indexKey?: KeysMatching<T, string | number>) => T[];
+    update: <T_1 extends Model>(data: T_1[], item: T_1, force?: boolean, partial?: boolean, indexKey?: KeysMatching<T_1, string | number>) => T_1[];
+    index: <T_2 extends Model>(data: T_2[], item: T_2, indexKey?: KeysMatching<T_2, string | number>) => number;
+    delete: <T_3 extends Model>(data: T_3[], item: T_3, indexKey?: KeysMatching<T_3, string | number>) => T_3[];
+    deleteBy: <T_4 extends Model>(data: T_4[], checkFunction: checkFunctionType<T_4>) => T_4[];
+    includes: <T_5 extends Model>(data: T_5[], item: T_5, indexKey?: KeysMatching<T_5, string | number>) => boolean;
+    upsert: <T_6 extends Model>(data: T_6[], item: T_6, atEnd?: boolean, force?: boolean, indexKey?: KeysMatching<T_6, string | number>) => T_6[];
+    insertMany: <T_7 extends Model>(data: T_7[], items: T_7[], atEnd?: boolean, indexKey?: KeysMatching<T_7, string | number>) => T_7[];
+    upsertMany: <T_8 extends Model>(data: T_8[], items: T_8[], atEnd?: boolean, force?: boolean, indexKey?: KeysMatching<T_8, string | number>) => T_8[];
+    groupBy: <T_9 extends BaseModel>(data: T_9[], key: KeysMatching<T_9, string | number>) => MappedModel<T_9>;
+    flatten: <T_10 extends BaseModel>(data: T_10[][]) => T_10[];
+    modify: <T_11 extends BaseModel>(instance: T_11, data: { [Property in keyof T_11]?: T_11[Property]; }) => any;
+};
+export {};

package/websocket/game.websocket.d.ts

@@ -0,0 +1,24 @@
+import { Game } from '../models/game';
+import { GameInvite } from '../models/game-invite';
+import { GameUser } from '../models/game-user';
+import { CentrifugoService } from '../services/centrifugo.service';
+import { Observable, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class GameWebsocket {
+    protected centrifugoService: CentrifugoService;
+    protected subscriptions: {
+        [key: number]: Subscription;
+    };
+    constructor(centrifugoService: CentrifugoService);
+    onGameUpdated$(gameId: number): Observable<Game>;
+    onGameClosed$(gameId: number): Observable<Game>;
+    onGameDeleted$(gameId: number): Observable<Game>;
+    onGameScoreUpdated$(gameId: number): Observable<Game>;
+    onGameInviteSent(gameId: number): Observable<GameInvite>;
+    onGameInviteAccepted(gameId: number): Observable<GameInvite>;
+    onGameInviteDeclined(gameId: number): Observable<GameInvite>;
+    onGameUserAdded(gameId: number): Observable<GameUser>;
+    onGameUserDeleted(gameId: number): Observable<GameUser>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GameWebsocket, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GameWebsocket>;
+}

package/websocket/public-api.d.ts

@@ -0,0 +1 @@
+export * from './game.websocket';