@depup/firebase__app 0.14.9-depup.0

package/dist/app/src/heartbeatService.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentContainer } from '@firebase/component';
+import { FirebaseApp } from './public-types';
+import { HeartbeatsByUserAgent, HeartbeatService, HeartbeatsInIndexedDB, HeartbeatStorage, SingleDateHeartbeat } from './types';
+export declare const MAX_NUM_STORED_HEARTBEATS = 30;
+export declare class HeartbeatServiceImpl implements HeartbeatService {
+    private readonly container;
+    /**
+     * The persistence layer for heartbeats
+     * Leave public for easier testing.
+     */
+    _storage: HeartbeatStorageImpl;
+    /**
+     * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate
+     * the header string.
+     * Stores one record per date. This will be consolidated into the standard
+     * format of one record per user agent string before being sent as a header.
+     * Populated from indexedDB when the controller is instantiated and should
+     * be kept in sync with indexedDB.
+     * Leave public for easier testing.
+     */
+    _heartbeatsCache: HeartbeatsInIndexedDB | null;
+    /**
+     * the initialization promise for populating heartbeatCache.
+     * If getHeartbeatsHeader() is called before the promise resolves
+     * (heartbeatsCache == null), it should wait for this promise
+     * Leave public for easier testing.
+     */
+    _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;
+    constructor(container: ComponentContainer);
+    /**
+     * Called to report a heartbeat. The function will generate
+     * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
+     * to IndexedDB.
+     * Note that we only store one heartbeat per day. So if a heartbeat for today is
+     * already logged, subsequent calls to this function in the same day will be ignored.
+     */
+    triggerHeartbeat(): Promise<void>;
+    /**
+     * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
+     * It also clears all heartbeats from memory as well as in IndexedDB.
+     *
+     * NOTE: Consuming product SDKs should not send the header if this method
+     * returns an empty string.
+     */
+    getHeartbeatsHeader(): Promise<string>;
+}
+export declare function extractHeartbeatsForHeader(heartbeatsCache: SingleDateHeartbeat[], maxSize?: number): {
+    heartbeatsToSend: HeartbeatsByUserAgent[];
+    unsentEntries: SingleDateHeartbeat[];
+};
+export declare class HeartbeatStorageImpl implements HeartbeatStorage {
+    app: FirebaseApp;
+    private _canUseIndexedDBPromise;
+    constructor(app: FirebaseApp);
+    runIndexedDBEnvironmentCheck(): Promise<boolean>;
+    /**
+     * Read all heartbeats.
+     */
+    read(): Promise<HeartbeatsInIndexedDB>;
+    overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
+}
+/**
+ * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped
+ * in a platform logging header JSON object, stringified, and converted
+ * to base 64.
+ */
+export declare function countBytes(heartbeatsCache: HeartbeatsByUserAgent[]): number;
+/**
+ * Returns the index of the heartbeat with the earliest date.
+ * If the heartbeats array is empty, -1 is returned.
+ */
+export declare function getEarliestHeartbeatIdx(heartbeats: SingleDateHeartbeat[]): number;

package/dist/app/src/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Firebase App
+ *
+ * @remarks This package coordinates the communication between the different Firebase components
+ * @packageDocumentation
+ */
+export * from './api';
+export * from './internal';
+export * from './public-types';

package/dist/app/src/indexeddb.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp } from './public-types';
+import { HeartbeatsInIndexedDB } from './types';
+export declare function readHeartbeatsFromIndexedDB(app: FirebaseApp): Promise<HeartbeatsInIndexedDB | undefined>;
+export declare function writeHeartbeatsToIndexedDB(app: FirebaseApp, heartbeatObject: HeartbeatsInIndexedDB): Promise<void>;

package/dist/app/src/internal.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp, FirebaseAppSettings, FirebaseServerAppSettings, FirebaseOptions, FirebaseServerApp } from './public-types';
+import { Component, Provider, Name } from '@firebase/component';
+import { DEFAULT_ENTRY_NAME } from './constants';
+/**
+ * @internal
+ */
+export declare const _apps: Map<string, FirebaseApp>;
+/**
+ * @internal
+ */
+export declare const _serverApps: Map<string, FirebaseServerApp>;
+/**
+ * Registered components.
+ *
+ * @internal
+ */
+export declare const _components: Map<string, Component<any>>;
+/**
+ * @param component - the component being added to this app's container
+ *
+ * @internal
+ */
+export declare function _addComponent<T extends Name>(app: FirebaseApp, component: Component<T>): void;
+/**
+ *
+ * @internal
+ */
+export declare function _addOrOverwriteComponent(app: FirebaseApp, component: Component): void;
+/**
+ *
+ * @param component - the component to register
+ * @returns whether or not the component is registered successfully
+ *
+ * @internal
+ */
+export declare function _registerComponent<T extends Name>(component: Component<T>): boolean;
+/**
+ *
+ * @param app - FirebaseApp instance
+ * @param name - service name
+ *
+ * @returns the provider for the service with the matching name
+ *
+ * @internal
+ */
+export declare function _getProvider<T extends Name>(app: FirebaseApp, name: T): Provider<T>;
+/**
+ *
+ * @param app - FirebaseApp instance
+ * @param name - service name
+ * @param instanceIdentifier - service instance identifier in case the service supports multiple instances
+ *
+ * @internal
+ */
+export declare function _removeServiceInstance<T extends Name>(app: FirebaseApp, name: T, instanceIdentifier?: string): void;
+/**
+ *
+ * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.
+ *
+ * @returns true if the provide object is of type FirebaseApp.
+ *
+ * @internal
+ */
+export declare function _isFirebaseApp(obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings): obj is FirebaseApp;
+/**
+ *
+ * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.
+ *
+ * @returns true if the provided object is of type FirebaseServerAppImpl.
+ *
+ * @internal
+ */
+export declare function _isFirebaseServerAppSettings(obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings): obj is FirebaseServerAppSettings;
+/**
+ *
+ * @param obj - an object of type FirebaseApp.
+ *
+ * @returns true if the provided object is of type FirebaseServerAppImpl.
+ *
+ * @internal
+ */
+export declare function _isFirebaseServerApp(obj: FirebaseApp | FirebaseServerApp | null | undefined): obj is FirebaseServerApp;
+/**
+ * Test only
+ *
+ * @internal
+ */
+export declare function _clearComponents(): void;
+/**
+ * Exported in order to be used in app-compat package
+ */
+export { DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME };

package/dist/app/src/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Logger } from '@firebase/logger';
+export declare const logger: Logger;

package/dist/app/src/platformLoggerService.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentContainer } from '@firebase/component';
+import { PlatformLoggerService } from './types';
+export declare class PlatformLoggerServiceImpl implements PlatformLoggerService {
+    private readonly container;
+    constructor(container: ComponentContainer);
+    getPlatformInfoString(): string;
+}

package/dist/app/src/public-types.d.ts

@@ -0,0 +1,241 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ComponentContainer } from '@firebase/component';
+import { PlatformLoggerService, VersionService, HeartbeatService } from './types';
+/**
+ * A {@link @firebase/app#FirebaseApp} holds the initialization information for a collection of
+ * services.
+ *
+ * Do not call this constructor directly. Instead, use
+ * {@link (initializeApp:1) | initializeApp()} to create an app.
+ *
+ * @public
+ */
+export interface FirebaseApp {
+    /**
+     * The (read-only) name for this app.
+     *
+     * The default app's name is `"[DEFAULT]"`.
+     *
+     * @example
+     * ```javascript
+     * // The default app's name is "[DEFAULT]"
+     * const app = initializeApp(defaultAppConfig);
+     * console.log(app.name);  // "[DEFAULT]"
+     * ```
+     *
+     * @example
+     * ```javascript
+     * // A named app's name is what you provide to initializeApp()
+     * const otherApp = initializeApp(otherAppConfig, "other");
+     * console.log(otherApp.name);  // "other"
+     * ```
+     */
+    readonly name: string;
+    /**
+     * The (read-only) configuration options for this app. These are the original
+     * parameters given in {@link (initializeApp:1) | initializeApp()}.
+     *
+     * @example
+     * ```javascript
+     * const app = initializeApp(config);
+     * console.log(app.options.databaseURL === config.databaseURL);  // true
+     * ```
+     */
+    readonly options: FirebaseOptions;
+    /**
+     * The settable config flag for GDPR opt-in/opt-out
+     */
+    automaticDataCollectionEnabled: boolean;
+}
+/**
+ * A {@link @firebase/app#FirebaseServerApp} holds the initialization information
+ * for a collection of services running in server environments.
+ *
+ * Do not call this constructor directly. Instead, use
+ * {@link (initializeServerApp:1) | initializeServerApp()} to create
+ * an app.
+ *
+ * @public
+ */
+export interface FirebaseServerApp extends FirebaseApp {
+    /**
+     * There is no `getApp()` operation for `FirebaseServerApp`, so the name is not relevant for
+     * applications. However, it may be used internally, and is declared here so that
+     * `FirebaseServerApp` conforms to the `FirebaseApp` interface.
+     */
+    name: string;
+    /**
+     * The (read-only) configuration settings for this server app. These are the original
+     * parameters given in {@link (initializeServerApp:1) | initializeServerApp()}.
+     *
+     * @example
+     * ```javascript
+     * const app = initializeServerApp(settings);
+     * console.log(app.settings.authIdToken === options.authIdToken);  // true
+     * ```
+     */
+    readonly settings: FirebaseServerAppSettings;
+}
+/**
+ * @public
+ *
+ * Firebase configuration object. Contains a set of parameters required by
+ * services in order to successfully communicate with Firebase server APIs
+ * and to associate client data with your Firebase project and
+ * Firebase application. Typically this object is populated by the Firebase
+ * console at project setup. See also:
+ * {@link https://firebase.google.com/docs/web/setup#config-object | Learn about the Firebase config object}.
+ */
+export interface FirebaseOptions {
+    /**
+     * An encrypted string used when calling certain APIs that don't need to
+     * access private user data
+     * (example value: `AIzaSyDOCAbC123dEf456GhI789jKl012-MnO`).
+     */
+    apiKey?: string;
+    /**
+     * Auth domain for the project ID.
+     */
+    authDomain?: string;
+    /**
+     * Default Realtime Database URL.
+     */
+    databaseURL?: string;
+    /**
+     * The unique identifier for the project across all of Firebase and
+     * Google Cloud.
+     */
+    projectId?: string;
+    /**
+     * The default Cloud Storage bucket name.
+     */
+    storageBucket?: string;
+    /**
+     * Unique numerical value used to identify each sender that can send
+     * Firebase Cloud Messaging messages to client apps.
+     */
+    messagingSenderId?: string;
+    /**
+     * Unique identifier for the app.
+     */
+    appId?: string;
+    /**
+     * An ID automatically created when you enable Analytics in your
+     * Firebase project and register a web app. In versions 7.20.0
+     * and higher, this parameter is optional.
+     */
+    measurementId?: string;
+}
+/**
+ * @public
+ *
+ * Configuration options given to {@link (initializeApp:1) | initializeApp()}
+ */
+export interface FirebaseAppSettings {
+    /**
+     * custom name for the Firebase App.
+     * The default value is `"[DEFAULT]"`.
+     */
+    name?: string;
+    /**
+     * The settable config flag for GDPR opt-in/opt-out. Defaults to true.
+     */
+    automaticDataCollectionEnabled?: boolean;
+}
+/**
+ * @public
+ *
+ * Configuration options given to {@link (initializeServerApp:1) | initializeServerApp()}
+ */
+export interface FirebaseServerAppSettings extends Omit<FirebaseAppSettings, 'name'> {
+    /**
+     * An optional Auth ID token used to resume a signed in user session from a client
+     * runtime environment.
+     *
+     * Invoking `getAuth` with a `FirebaseServerApp` configured with a validated `authIdToken`
+     * causes an automatic attempt to sign in the user that the `authIdToken` represents. The token
+     * needs to have been recently minted for this operation to succeed.
+     *
+     * If the token fails local verification due to expiration or parsing errors, then a console error
+     * is logged at the time of initialization of the `FirebaseServerApp` instance.
+     *
+     * If the Auth service has failed to validate the token when the Auth SDK is initialized, then an
+     * warning is logged to the console and the Auth SDK will not sign in a user on initialization.
+     *
+     * If a user is successfully signed in, then the Auth instance's `onAuthStateChanged` callback
+     * is invoked with the `User` object as per standard Auth flows. However, `User` objects
+     * created via an `authIdToken` do not have a refresh token. Attempted `refreshToken`
+     * operations fail.
+     */
+    authIdToken?: string;
+    /**
+     * An optional App Check token. If provided, the Firebase SDKs that use App Check will utilize
+     * this App Check token in place of requiring an instance of App Check to be initialized.
+     *
+     * If the token fails local verification due to expiration or parsing errors, then a console error
+     * is logged at the time of initialization of the `FirebaseServerApp` instance.
+     */
+    appCheckToken?: string;
+    /**
+     * An optional object. If provided, the Firebase SDK uses a `FinalizationRegistry`
+     * object to monitor the garbage collection status of the provided object. The
+     * Firebase SDK releases its reference on the `FirebaseServerApp` instance when the
+     * provided `releaseOnDeref` object is garbage collected.
+     *
+     * You can use this field to reduce memory management overhead for your application.
+     * If provided, an app running in a SSR pass does not need to perform
+     * `FirebaseServerApp` cleanup, so long as the reference object is deleted (by falling out of
+     * SSR scope, for instance.)
+     *
+     * If an object is not provided then the application must clean up the `FirebaseServerApp`
+     * instance by invoking `deleteApp`.
+     *
+     * If the application provides an object in this parameter, but the application is
+     * executed in a JavaScript engine that predates the support of `FinalizationRegistry`
+     * (introduced in node v14.6.0, for instance), then an error is thrown at `FirebaseServerApp`
+     * initialization.
+     */
+    releaseOnDeref?: object;
+}
+/**
+ * @internal
+ */
+export interface _FirebaseService {
+    app: FirebaseApp;
+    /**
+     * Delete the service and free it's resources - called from
+     * {@link @firebase/app#deleteApp | deleteApp()}
+     */
+    _delete(): Promise<void>;
+}
+/**
+ * @internal
+ */
+export interface _FirebaseAppInternal extends FirebaseApp {
+    container: ComponentContainer;
+    isDeleted: boolean;
+    checkDestroyed(): void;
+}
+declare module '@firebase/component' {
+    interface NameServiceMapping {
+        'app': FirebaseApp;
+        'app-version': VersionService;
+        'heartbeat': HeartbeatService;
+        'platform-logger': PlatformLoggerService;
+    }
+}

package/dist/app/src/registerCoreComponents.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function registerCoreComponents(variant?: string): void;

package/dist/app/src/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "0.1.2"
+    }
+  ]
+}

package/dist/app/src/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export interface VersionService {
+    library: string;
+    version: string;
+}
+export interface PlatformLoggerService {
+    getPlatformInfoString(): string;
+}
+export interface HeartbeatService {
+    /**
+     * Called to report a heartbeat. The function will generate
+     * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
+     * to IndexedDB.
+     * Note that we only store one heartbeat per day. So if a heartbeat for today is
+     * already logged, subsequent calls to this function in the same day will be ignored.
+     */
+    triggerHeartbeat(): Promise<void>;
+    /**
+     * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
+     * It also clears all heartbeats from memory as well as in IndexedDB.
+     */
+    getHeartbeatsHeader(): Promise<string>;
+}
+export interface HeartbeatsByUserAgent {
+    agent: string;
+    dates: string[];
+}
+export interface SingleDateHeartbeat {
+    agent: string;
+    date: string;
+}
+export interface HeartbeatStorage {
+    overwrite(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    read(): Promise<HeartbeatsInIndexedDB>;
+}
+export interface HeartbeatsInIndexedDB {
+    lastSentHeartbeatDate?: string;
+    heartbeats: SingleDateHeartbeat[];
+}

package/dist/app/test/setup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/app/test/util.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp, _FirebaseService } from '../src/public-types';
+import { ComponentType, Component } from '@firebase/component';
+export declare class TestService implements _FirebaseService {
+    private app_;
+    instanceIdentifier?: string | undefined;
+    constructor(app_: FirebaseApp, instanceIdentifier?: string | undefined);
+    get app(): FirebaseApp;
+    _delete(): Promise<void>;
+}
+export declare function createTestComponent(name: string, multiInstances?: boolean, type?: ComponentType): Component;