entropic-bond 1.60.0 → 1.60.1

package/lib/auth/auth-mock.d.ts

@@ -0,0 +1,22 @@
+import { Collection } from '../types/utility-types';
+import { AuthService } from "./auth";
+import { UserCredentials, SignData, AuthProvider, CredentialsCustomData } from "./user-auth-types";
+export declare class AuthMock extends AuthService {
+    signUp<T extends CredentialsCustomData>(signData: SignData): Promise<UserCredentials<T>>;
+    login<T extends CredentialsCustomData>(signData: SignData): Promise<UserCredentials<T>>;
+    onAuthStateChange<T extends CredentialsCustomData>(onChange: (userCredentials: UserCredentials<T>) => void): void;
+    logout(): Promise<void>;
+    resetEmailPassword(email: string): Promise<void>;
+    resendVerificationEmail(email: string, _password: string, _verificationLink: string): Promise<void>;
+    refreshToken(): Promise<void>;
+    linkAdditionalProvider(provider: AuthProvider): Promise<unknown>;
+    unlinkProvider(provider: AuthProvider): Promise<unknown>;
+    flush(): Promise<void>;
+    fakeRegisteredUser<T extends CredentialsCustomData>(userCredentials: UserCredentials<T>): this;
+    get fakeRegisteredUsers(): Collection<UserCredentials<CredentialsCustomData>>;
+    private userCredentials;
+    private pendingPromises;
+    private _loggedUser;
+    private notifyChange;
+    private _fakeRegisteredUsers;
+}

package/lib/auth/auth.d.ts

@@ -0,0 +1,131 @@
+import { AuthProvider, CredentialsCustomData, SignData, UserCredentials } from "./user-auth-types";
+/**
+ * The AuthService class is an abstract class that defines the interface of an authentication service.
+ * You should derive from this class to implement your own authentication service.
+ */
+export declare abstract class AuthService {
+    abstract signUp<T extends CredentialsCustomData>(signData: SignData): Promise<UserCredentials<T>>;
+    abstract login<T extends CredentialsCustomData>(signData: SignData): Promise<UserCredentials<T>>;
+    abstract logout(): Promise<void>;
+    abstract resetEmailPassword(email: string): Promise<void>;
+    abstract refreshToken(): Promise<void>;
+    abstract linkAdditionalProvider(provider: AuthProvider): Promise<unknown>;
+    abstract unlinkProvider(provider: AuthProvider): Promise<unknown>;
+    abstract onAuthStateChange<T extends CredentialsCustomData>(onChange: (userCredentials: UserCredentials<T> | undefined) => void): void;
+    abstract resendVerificationEmail(email: string, password: string, verificationLink: string): Promise<void>;
+}
+export type AuthErrorCode = 'wrongPassword' | 'popupClosedByUser' | 'userNotFound' | 'invalidEmail' | 'missingPassword' | 'missingEmail';
+export interface AuthError {
+    code: AuthErrorCode;
+    message: string;
+}
+/**
+ * Types the callback to accept a user credentials object
+ */
+export type ResovedCallback<T extends CredentialsCustomData> = (credentials: UserCredentials<T>) => void;
+export type RejectedCallback = (reason: AuthError) => void;
+/**
+ * The Auth class is a singleton that provides a unified interface to the authentication service.
+ * You should register an authentication service by using `Auth.useAuthService`
+ * method before using the Auth class.
+ */
+export declare class Auth extends AuthService {
+    static error: {
+        shouldBeRegistered: string;
+    };
+    protected constructor();
+    /**
+     * Registers an authentication service to be used by the Auth class.
+     * You need to register an authentication service before using the Auth class.
+     * @param authService the authentication service to be used by the Auth class
+     */
+    static useAuthService(authService: AuthService): void;
+    /**
+     * The instance of the Auth class
+     * @returns the authentication service
+     */
+    static get instance(): Auth;
+    /**
+     * Signs up a new user
+     * @param singData the data to be used to sign up the user
+     * @returns a promise that resolves to the user credentials
+     * @example
+     * // Sign up a new user with email and password
+     * Auth.instance.signUp({ authProvider: 'email', email: 'john@test.com', password: '123456' })
+     * // Sign up a new user with a Google account
+     * Auth.instance.signUp({ authProvider: 'google'})
+     */
+    signUp<T extends CredentialsCustomData>(singData: SignData): Promise<UserCredentials<T>>;
+    /**
+     * Logs in an existing user
+     * @param singData the data to be used to log in the user
+     * @returns a promise that resolves to the user credentials
+     * @example
+     * // Log in an existing user with email and password
+     * Auth.instance.login({ authProvider: 'email', email: 'john@test.com', password: '123456' })
+     * // Log in an existing user with a Google account
+     * Auth.instance.login({ authProvider: 'google'})
+     */
+    login<T extends CredentialsCustomData>(singData: SignData): Promise<UserCredentials<T>>;
+    /**
+     * Logs out the current user
+     * @returns a promise that resolves when the user is logged out
+     */
+    logout(): Promise<void>;
+    /**
+     * Resets the password associated with the email.
+     * @param email the email address of the user to reset the password
+     * @returns a promise that resolves when the process is done
+     */
+    resetEmailPassword(email: string): Promise<void>;
+    /**
+     * Resends the email verification to the user.
+     * @returns a promise that resolves when the process is done
+     */
+    resendVerificationEmail(email: string, password: string, verificationLink: string): Promise<void>;
+    refreshToken(): Promise<void>;
+    /**
+     * Adds a listener to be called when the authentication state changes.
+     * @param onChange the listener to be called when the authentication state changes.
+     * The listener is called with the user credentials as a parameter.
+     * If the user is logged out, the listener is called with `undefined` as a parameter.
+     * @returns a function to remove the listener
+     * @example
+     * // Add a listener to be called when the authentication state changes
+     * const removeListener = Auth.instance.onAuthStateChange( userCredentials => {
+     * 	if ( userCredentials ) {
+     * 		// The user is logged in
+     * 	} else {
+     * 		// The user is logged out
+     * 	}
+     * })
+     */
+    onAuthStateChange<T extends CredentialsCustomData>(onChange: (userCredentials: UserCredentials<T>) => void): import("..").Unsubscriber;
+    /**
+     * Removes a listener that was added by `onAuthStateChange` method.
+     * @param onChange the listener to be removed
+     */
+    removeAuthStateChange<T extends CredentialsCustomData>(onChange: (userCredentials: UserCredentials<T>) => void): void;
+    /**
+     * Links an additional authentication provider to the authenticated user.
+     * @param provider the provider to be linked
+     * @returns a promise that resolves when the process is done
+     * @example
+     * // Link a Google account to the auth service
+     * Auth.instance.linkAdditionalProvider({ authProvider: 'google' })
+     */
+    linkAdditionalProvider(provider: AuthProvider): Promise<unknown>;
+    /**
+     * Unlinks an authentication provider from the authenticated user.
+     * @param provider the provider to be unlinked
+     * @returns a promise that resolves when the process is done
+     * @example
+     * // Unlink the Google account from the auth service
+     * Auth.instance.unlinkProvider({ authProvider: 'google' })
+     */
+    unlinkProvider(provider: AuthProvider): Promise<unknown>;
+    private authStateChanged;
+    private static _instance;
+    private static _authService;
+    private _onAuthStateChange;
+}

package/lib/auth/user-auth-types.d.ts

@@ -0,0 +1,22 @@
+export interface CredentialsCustomData {
+    [key: string]: any;
+}
+export interface UserCredentials<T extends CredentialsCustomData = {}> {
+    id: string;
+    email: string;
+    name?: string;
+    pictureUrl?: string;
+    phoneNumber?: string;
+    emailVerified?: boolean;
+    customData?: T;
+    lastLogin?: number;
+    creationDate?: number;
+}
+export type AuthProvider = 'email' | 'facebook' | 'google' | 'twitter';
+export interface SignData {
+    authProvider: AuthProvider;
+    email?: string;
+    password?: string;
+    name?: string;
+    verificationLink?: string;
+}

package/lib/cloud-functions/cloud-functions-mock.d.ts

@@ -0,0 +1,10 @@
+import { CloudFunction, CloudFunctionsService } from './cloud-functions';
+export interface FunctionCollection {
+    [key: string]: CloudFunction<any, any>;
+}
+export declare class CloudFunctionsMock implements CloudFunctionsService {
+    constructor(registeredFunctions: FunctionCollection);
+    retrieveFunction<P, R>(cloudFunction: string): CloudFunction<P, R>;
+    callFunction<P, R>(func: CloudFunction<P, R>, params: P): Promise<R>;
+    private _registeredFunctions;
+}

package/lib/cloud-functions/cloud-functions.d.ts

@@ -0,0 +1,19 @@
+export type CloudFunction<P, R> = (param?: P) => Promise<R>;
+export interface CloudFunctionsService {
+    retrieveFunction<P, R>(cloudFunction: string): CloudFunction<P, R>;
+    callFunction<P, R>(func: CloudFunction<P, R>, params: P): Promise<R>;
+}
+export declare class CloudFunctions {
+    private constructor();
+    static error: {
+        shouldBeRegistered: string;
+    };
+    static useCloudFunctionsService(cloudFunctionsService: CloudFunctionsService): void;
+    static get instance(): CloudFunctions;
+    getRawFunction<P, R>(cloudFunction: string): CloudFunction<P, R>;
+    getFunction<P, R = void>(cloudFunction: string): CloudFunction<P, R>;
+    private processParam;
+    private processResult;
+    private static _cloudFunctionsService;
+    private static _instance;
+}

package/lib/cloud-storage/cloud-storage.d.ts

@@ -0,0 +1,23 @@
+export type UploadProgress = (uploadedBytes: number, fileSize: number) => void;
+export type CloudStorageFactory = () => CloudStorage;
+export interface UploadControl {
+    pause: () => void;
+    resume: () => void;
+    cancel: () => void;
+    onProgress: (callback: UploadProgress) => void;
+}
+export type StorableData = File | Blob | Uint8Array | ArrayBuffer;
+export declare abstract class CloudStorage {
+    abstract save(id: string, data: StorableData, progress?: UploadProgress): Promise<string>;
+    abstract getUrl(reference: string): Promise<string>;
+    abstract uploadControl(): UploadControl;
+    abstract delete(reference: string): Promise<void>;
+    static registerCloudStorage(cloudStorageProviderName: string, factory: CloudStorageFactory): void;
+    static createInstance(providerName: string): CloudStorage;
+    get className(): string;
+    static useCloudStorage(provider: CloudStorage): void;
+    static get defaultCloudStorage(): CloudStorage;
+    static _defaultCloudStorage: CloudStorage;
+    private static _cloudStorageFactoryMap;
+}
+export declare function registerCloudStorage(cloudStorageProviderName: string, factory: CloudStorageFactory): (constructor: Function) => void;

package/lib/cloud-storage/mock-cloud-storage.d.ts

@@ -0,0 +1,20 @@
+import { CloudStorage, StorableData, UploadControl } from './cloud-storage';
+export declare class MockCloudStorage extends CloudStorage {
+    constructor(pathToMockFiles?: string);
+    /**
+     * Introduce a delay in the execution of operations to simulate a real data source
+     * @param miliSeconds the number of milliseconds to delay the execution of operations
+     * @returns a chainable reference to this object
+     */
+    simulateDelay(miliSeconds: number): this;
+    private resolveWithDelay;
+    save(id: string, data: StorableData): Promise<string>;
+    uploadControl(): UploadControl;
+    getUrl(reference: string): Promise<string>;
+    delete(reference: string): Promise<void>;
+    private _simulateDelay;
+    private _pendingPromises;
+    private _onProgress;
+    private _pathToMockFiles;
+    mockFileSystem: {};
+}

package/lib/cloud-storage/stored-file.d.ts

@@ -0,0 +1,39 @@
+import { Callback } from '../observable/observable';
+import { Persistent } from '../persistent/persistent';
+import { CloudStorage, StorableData, UploadControl, UploadProgress } from './cloud-storage';
+export declare enum StoredFileEvent {
+    stored = 0,
+    pendingDataSet = 1,
+    deleted = 2
+}
+export interface StoredFileChange {
+    event: StoredFileEvent;
+    pendingData?: StorableData;
+    storedFile: StoredFile;
+}
+export interface StoreParams {
+    data?: StorableData;
+    fileName?: string;
+    progress?: UploadProgress;
+    cloudStorageProvider?: CloudStorage;
+}
+export declare class StoredFile extends Persistent {
+    save({ data, fileName, progress, cloudStorageProvider }?: StoreParams): Promise<void>;
+    uploadControl(): UploadControl;
+    delete(): Promise<void>;
+    set provider(value: CloudStorage);
+    get provider(): CloudStorage;
+    get url(): string | undefined;
+    get mimeType(): string | undefined;
+    setDataToStore(data: StorableData): this;
+    get originalFileName(): string | undefined;
+    onChange(listenerCallback: Callback<StoredFileChange>): import("..").Unsubscriber;
+    private _reference;
+    private _url;
+    private _cloudStorageProviderName;
+    private _originalFileName;
+    private _mimeType;
+    private _provider;
+    private _pendingData;
+    private _onChange;
+}

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+export * from './observable/observable';
+export * from './persistent/entropic-component';
+export * from './persistent/persistent';
+export * from './store/data-source';
+export * from './store/cached-props-updater';
+export * from './store/json-data-source';
+export * from './store/store';
+export * from './store/model';
+export * from './types/utility-types';
+export * from './cloud-storage/cloud-storage';
+export * from './cloud-storage/mock-cloud-storage';
+export * from './cloud-storage/stored-file';
+export * from './auth/auth';
+export * from './auth/user-auth-types';
+export * from './auth/auth-mock';
+export * from './cloud-functions/cloud-functions';
+export * from './cloud-functions/cloud-functions-mock';
+export * from './server-auth/server-auth';
+export * from './server-auth/server-auth-mock';
+export * from './utils/utils';

package/lib/observable/observable.d.ts

@@ -0,0 +1,52 @@
+export type Callback<T> = (event: T) => void;
+export type Unsubscriber = () => void;
+/**
+ * Implements the Observer pattern.
+ * The Observable class is used to notify a list of subscribers when an event occurs.
+ * The subscribers are callback functions that are called when the event occurs.
+ * The event is passed as a parameter to the callback function.
+ * @example
+ * // Create an observable
+ * const observable = new Observable<number>()
+ * // Subscribe a listener
+ * const unsubscribe = observable.subscribe( event => console.log( event ) )
+ * // Notify the subscribers
+ * observable.notify( 1 )
+ * // Unsubscribe the listener
+ * unsubscribe()
+ */
+export declare class Observable<T> {
+    /**
+     * Subscribes a listener callback function. On every notification,
+     * the listener callback will be called with an event as a parameter if sent.
+     *
+     * @param callback the listener callback
+     * @returns a function to unsubscribe the listener from further notifications
+     */
+    subscribe(callback: Callback<T>): Unsubscriber;
+    /**
+     * Removes the callback from the notification list.
+     *
+     * @param callback the listener callback to remove
+     */
+    unsubscribe(callback: Callback<T>): void;
+    /**
+     * Notifies all the subscribers with the event passed as parameter.
+     *
+     * @param event the event passed to all subscribers.
+     */
+    notify(event?: T): void;
+    /**
+     * Returns the number of subscribers.
+     *
+     * @returns the number of subscribers
+     * @example
+     * const observable = new Observable<number>()
+     * observable.subscribe( event => console.log( event ) )
+     * observable.subscribe( event => console.log( event ) )
+     * observable.subscribe( event => console.log( event ) )
+     * console.log( observable.subscribersCount ) // 3
+     */
+    get subscribersCount(): number;
+    private subscribers;
+}

package/lib/persistent/entropic-component.d.ts

@@ -0,0 +1,75 @@
+import { Callback, Unsubscriber } from '../observable/observable';
+import { ClassProps } from '../types/utility-types';
+import { Persistent } from './persistent';
+export type PropChangeEvent<T> = Partial<ClassProps<T>>;
+export type PropChangeCallback<T> = Callback<PropChangeEvent<T>>;
+export type CompareFunction<T> = (a: T, b: T) => boolean;
+/**
+ * Derived classes from EntropicComponent will have the ability to notify
+ * property changes by calling one of the provided notification methods.
+ * It extends Persistent class therefore EntropicComponent children will have
+ * persistence through the Entropic Bond persistence mechanism
+ */
+export type StrictElement<T> = T extends any ? (keyof T extends never ? never : T) : never;
+export declare class EntropicComponent extends Persistent {
+    /**
+     * Subscribes a listener callback function. Every time a property is changed,
+     * the listener callback will be called with the property change event.
+     *
+     * @param listenerCallback the listener callback
+     * @returns a function to unsubscribe the listener from further notifications
+     */
+    onChange(listenerCallback: PropChangeCallback<this>): Unsubscriber;
+    /**
+     * Removes the listener callback subscrition from the notifications.
+     *
+     * @param listenerCallback the listener callback to remove
+     */
+    removeOnChange(listenerCallback: PropChangeCallback<this>): void;
+    /**
+     * Changes the value of the property and notifies the subscribers about the change.
+     * This is a helper method that can be used in the property setter.
+     *
+     * @param propName the name of the property to be changed
+     * @param value the new value for the property
+     * @returns true in case the property has been effectively changed, false otherwise
+     */
+    protected changeProp<P extends keyof this>(propName: P, value: this[P]): boolean;
+    /**
+     * Notifies the subscribers a property or group of properties change.
+     * This is a helper function to be used when you want to notify property changes.
+     *
+     * @param event the event with the changed properties
+     */
+    protected notify<T extends EntropicComponent>(event: PropChangeEvent<T>): void;
+    /**
+     * Inserts a new element in an arbitrary array property of this class and
+     * fires a change event if successfully inserted. To avoid repeated elements
+     * to be inserted, you can pass a function that checks for inequity.
+     *
+     * @param arrayPropName the name of the array property of this class where you
+     * 											want to insert the	new element.
+     * @param element the element to be inserted
+     * @param isUnique a function that checks for inequity of the two elements
+     * 									passed as parameter. If the returned value is true, the
+     * 									value will be	pushed into the array. When the function is
+     * 									not provided, the element will be inserted regardless it is
+     * 									already in the array.
+     * @returns the inserted element or undefined if the element was not inserted.
+     */
+    protected pushAndNotify<T extends keyof this, E>(this: Record<T, readonly E[]> & EntropicComponent, arrayPropName: T, element: StrictElement<E>, isUnique?: CompareFunction<StrictElement<E>>): E | undefined;
+    /**
+     * Removes an element from an arbitrary array property of this class and fires
+     * a change event on operation success.
+     *
+     * @param arrayPropName the name of the array property of this class where you
+     * 											want to insert the	new element.
+     * @param element the element to be inserted
+     * @param isEqual a function that checks for equity of the two elements
+     * 									passed as parameter. If the returned value is true, the
+     * 									value will be	removed from the array.
+     * @returns the removed element or undefined if the element was not removed.
+     */
+    protected removeAndNotify<T extends keyof this, E>(this: Record<T, readonly E[]> & EntropicComponent, arrayPropName: T, element: StrictElement<E>, isEqual: CompareFunction<StrictElement<E>>): E | undefined;
+    private _onChange;
+}