entropic-bond 1.50.0 → 1.50.2

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 } from "./user-auth-types";
+export declare class AuthMock extends AuthService {
+    signUp<T extends {}>(signData: SignData): Promise<UserCredentials<T>>;
+    login<T extends {}>(signData: SignData): Promise<UserCredentials<T>>;
+    onAuthStateChange<T extends {}>(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 {}>(userCredentials: UserCredentials<T>): this;
+    get fakeRegisteredUsers(): Collection<UserCredentials<{}>>;
+    private userCredentials;
+    private pendingPromises;
+    private _loggedUser;
+    private notifyChange;
+    private _fakeRegisteredUsers;
+}

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

@@ -0,0 +1 @@
+export {};

package/lib/auth/auth.d.ts

@@ -0,0 +1,131 @@
+import { AuthProvider, 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 {}>(signData: SignData): Promise<UserCredentials<T>>;
+    abstract login<T extends {}>(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 {}>(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 {}> = (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 {}>(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 {}>(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 {}>(onChange: (userCredentials: UserCredentials<T>) => void): import("../observable/observable").Unsubscriber;
+    /**
+     * Removes a listener that was added by `onAuthStateChange` method.
+     * @param onChange the listener to be removed
+     */
+    removeAuthStateChange<T extends {}>(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,19 @@
+export interface UserCredentials<T extends {} = {}> {
+    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,11 @@
+import { CloudFunction, CloudFunctionsService } from './cloud-functions';
+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;
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

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,24 @@
+export type UploadProgress = (uploadedBytes: number, fileSize: number) => void;
+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;
+export {};

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

@@ -0,0 +1 @@
+export {};

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("../observable/observable").Unsubscriber;
+    private _reference;
+    private _url;
+    private _cloudStorageProviderName;
+    private _originalFileName;
+    private _mimeType;
+    private _provider;
+    private _pendingData;
+    private _onChange;
+}