You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
431 lines
16 KiB
431 lines
16 KiB
import { ErrorFactory, contains, deepExtend, createSubscribe, isBrowser } from '@firebase/util';
|
|
import { Component } from '@firebase/component';
|
|
import * as modularAPIs from '@firebase/app';
|
|
import { _addComponent, deleteApp, _DEFAULT_ENTRY_NAME, _addOrOverwriteComponent, registerVersion } from '@firebase/app';
|
|
import { Logger } from '@firebase/logger';
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* Global context object for a collection of services using
|
|
* a shared authentication state.
|
|
*
|
|
* marked as internal because it references internal types exported from @firebase/app
|
|
* @internal
|
|
*/
|
|
class FirebaseAppImpl {
|
|
constructor(_delegate, firebase) {
|
|
this._delegate = _delegate;
|
|
this.firebase = firebase;
|
|
// add itself to container
|
|
_addComponent(_delegate, new Component('app-compat', () => this, "PUBLIC" /* ComponentType.PUBLIC */));
|
|
this.container = _delegate.container;
|
|
}
|
|
get automaticDataCollectionEnabled() {
|
|
return this._delegate.automaticDataCollectionEnabled;
|
|
}
|
|
set automaticDataCollectionEnabled(val) {
|
|
this._delegate.automaticDataCollectionEnabled = val;
|
|
}
|
|
get name() {
|
|
return this._delegate.name;
|
|
}
|
|
get options() {
|
|
return this._delegate.options;
|
|
}
|
|
delete() {
|
|
return new Promise(resolve => {
|
|
this._delegate.checkDestroyed();
|
|
resolve();
|
|
}).then(() => {
|
|
this.firebase.INTERNAL.removeApp(this.name);
|
|
return deleteApp(this._delegate);
|
|
});
|
|
}
|
|
/**
|
|
* Return a service instance associated with this app (creating it
|
|
* on demand), identified by the passed instanceIdentifier.
|
|
*
|
|
* NOTE: Currently storage and functions are the only ones that are leveraging this
|
|
* functionality. They invoke it by calling:
|
|
*
|
|
* ```javascript
|
|
* firebase.app().storage('STORAGE BUCKET ID')
|
|
* ```
|
|
*
|
|
* The service name is passed to this already
|
|
* @internal
|
|
*/
|
|
_getService(name, instanceIdentifier = _DEFAULT_ENTRY_NAME) {
|
|
var _a;
|
|
this._delegate.checkDestroyed();
|
|
// Initialize instance if InstatiationMode is `EXPLICIT`.
|
|
const provider = this._delegate.container.getProvider(name);
|
|
if (!provider.isInitialized() &&
|
|
((_a = provider.getComponent()) === null || _a === void 0 ? void 0 : _a.instantiationMode) === "EXPLICIT" /* InstantiationMode.EXPLICIT */) {
|
|
provider.initialize();
|
|
}
|
|
// getImmediate will always succeed because _getService is only called for registered components.
|
|
return provider.getImmediate({
|
|
identifier: instanceIdentifier
|
|
});
|
|
}
|
|
/**
|
|
* Remove a service instance from the cache, so we will create a new instance for this service
|
|
* when people try to get it again.
|
|
*
|
|
* NOTE: currently only firestore uses this functionality to support firestore shutdown.
|
|
*
|
|
* @param name The service name
|
|
* @param instanceIdentifier instance identifier in case multiple instances are allowed
|
|
* @internal
|
|
*/
|
|
_removeServiceInstance(name, instanceIdentifier = _DEFAULT_ENTRY_NAME) {
|
|
this._delegate.container
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
.getProvider(name)
|
|
.clearInstance(instanceIdentifier);
|
|
}
|
|
/**
|
|
* @param component the component being added to this app's container
|
|
* @internal
|
|
*/
|
|
_addComponent(component) {
|
|
_addComponent(this._delegate, component);
|
|
}
|
|
_addOrOverwriteComponent(component) {
|
|
_addOrOverwriteComponent(this._delegate, component);
|
|
}
|
|
toJSON() {
|
|
return {
|
|
name: this.name,
|
|
automaticDataCollectionEnabled: this.automaticDataCollectionEnabled,
|
|
options: this.options
|
|
};
|
|
}
|
|
}
|
|
// TODO: investigate why the following needs to be commented out
|
|
// Prevent dead-code elimination of these methods w/o invalid property
|
|
// copying.
|
|
// (FirebaseAppImpl.prototype.name && FirebaseAppImpl.prototype.options) ||
|
|
// FirebaseAppImpl.prototype.delete ||
|
|
// console.log('dc');
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
const ERRORS = {
|
|
["no-app" /* AppError.NO_APP */]: "No Firebase App '{$appName}' has been created - " +
|
|
'call Firebase App.initializeApp()',
|
|
["invalid-app-argument" /* AppError.INVALID_APP_ARGUMENT */]: 'firebase.{$appName}() takes either no argument or a ' +
|
|
'Firebase App instance.'
|
|
};
|
|
const ERROR_FACTORY = new ErrorFactory('app-compat', 'Firebase', ERRORS);
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* Because auth can't share code with other components, we attach the utility functions
|
|
* in an internal namespace to share code.
|
|
* This function return a firebase namespace object without
|
|
* any utility functions, so it can be shared between the regular firebaseNamespace and
|
|
* the lite version.
|
|
*/
|
|
function createFirebaseNamespaceCore(firebaseAppImpl) {
|
|
const apps = {};
|
|
// // eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
// const components = new Map<string, Component<any>>();
|
|
// A namespace is a plain JavaScript Object.
|
|
const namespace = {
|
|
// Hack to prevent Babel from modifying the object returned
|
|
// as the firebase namespace.
|
|
// @ts-ignore
|
|
__esModule: true,
|
|
initializeApp: initializeAppCompat,
|
|
// @ts-ignore
|
|
app,
|
|
registerVersion: modularAPIs.registerVersion,
|
|
setLogLevel: modularAPIs.setLogLevel,
|
|
onLog: modularAPIs.onLog,
|
|
// @ts-ignore
|
|
apps: null,
|
|
SDK_VERSION: modularAPIs.SDK_VERSION,
|
|
INTERNAL: {
|
|
registerComponent: registerComponentCompat,
|
|
removeApp,
|
|
useAsService,
|
|
modularAPIs
|
|
}
|
|
};
|
|
// Inject a circular default export to allow Babel users who were previously
|
|
// using:
|
|
//
|
|
// import firebase from 'firebase';
|
|
// which becomes: var firebase = require('firebase').default;
|
|
//
|
|
// instead of
|
|
//
|
|
// import * as firebase from 'firebase';
|
|
// which becomes: var firebase = require('firebase');
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
namespace['default'] = namespace;
|
|
// firebase.apps is a read-only getter.
|
|
Object.defineProperty(namespace, 'apps', {
|
|
get: getApps
|
|
});
|
|
/**
|
|
* Called by App.delete() - but before any services associated with the App
|
|
* are deleted.
|
|
*/
|
|
function removeApp(name) {
|
|
delete apps[name];
|
|
}
|
|
/**
|
|
* Get the App object for a given name (or DEFAULT).
|
|
*/
|
|
function app(name) {
|
|
name = name || modularAPIs._DEFAULT_ENTRY_NAME;
|
|
if (!contains(apps, name)) {
|
|
throw ERROR_FACTORY.create("no-app" /* AppError.NO_APP */, { appName: name });
|
|
}
|
|
return apps[name];
|
|
}
|
|
// @ts-ignore
|
|
app['App'] = firebaseAppImpl;
|
|
/**
|
|
* Create a new App instance (name must be unique).
|
|
*
|
|
* This function is idempotent. It can be called more than once and return the same instance using the same options and config.
|
|
*/
|
|
function initializeAppCompat(options, rawConfig = {}) {
|
|
const app = modularAPIs.initializeApp(options, rawConfig);
|
|
if (contains(apps, app.name)) {
|
|
return apps[app.name];
|
|
}
|
|
const appCompat = new firebaseAppImpl(app, namespace);
|
|
apps[app.name] = appCompat;
|
|
return appCompat;
|
|
}
|
|
/*
|
|
* Return an array of all the non-deleted FirebaseApps.
|
|
*/
|
|
function getApps() {
|
|
// Make a copy so caller cannot mutate the apps list.
|
|
return Object.keys(apps).map(name => apps[name]);
|
|
}
|
|
function registerComponentCompat(component) {
|
|
const componentName = component.name;
|
|
const componentNameWithoutCompat = componentName.replace('-compat', '');
|
|
if (modularAPIs._registerComponent(component) &&
|
|
component.type === "PUBLIC" /* ComponentType.PUBLIC */) {
|
|
// create service namespace for public components
|
|
// The Service namespace is an accessor function ...
|
|
const serviceNamespace = (appArg = app()) => {
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
if (typeof appArg[componentNameWithoutCompat] !== 'function') {
|
|
// Invalid argument.
|
|
// This happens in the following case: firebase.storage('gs:/')
|
|
throw ERROR_FACTORY.create("invalid-app-argument" /* AppError.INVALID_APP_ARGUMENT */, {
|
|
appName: componentName
|
|
});
|
|
}
|
|
// Forward service instance lookup to the FirebaseApp.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
return appArg[componentNameWithoutCompat]();
|
|
};
|
|
// ... and a container for service-level properties.
|
|
if (component.serviceProps !== undefined) {
|
|
deepExtend(serviceNamespace, component.serviceProps);
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
namespace[componentNameWithoutCompat] = serviceNamespace;
|
|
// Patch the FirebaseAppImpl prototype
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
firebaseAppImpl.prototype[componentNameWithoutCompat] =
|
|
// TODO: The eslint disable can be removed and the 'ignoreRestArgs'
|
|
// option added to the no-explicit-any rule when ESlint releases it.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function (...args) {
|
|
const serviceFxn = this._getService.bind(this, componentName);
|
|
return serviceFxn.apply(this, component.multipleInstances ? args : []);
|
|
};
|
|
}
|
|
return component.type === "PUBLIC" /* ComponentType.PUBLIC */
|
|
? // eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
namespace[componentNameWithoutCompat]
|
|
: null;
|
|
}
|
|
// Map the requested service to a registered service name
|
|
// (used to map auth to serverAuth service when needed).
|
|
function useAsService(app, name) {
|
|
if (name === 'serverAuth') {
|
|
return null;
|
|
}
|
|
const useService = name;
|
|
return useService;
|
|
}
|
|
return namespace;
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* Return a firebase namespace object.
|
|
*
|
|
* In production, this will be called exactly once and the result
|
|
* assigned to the 'firebase' global. It may be called multiple times
|
|
* in unit tests.
|
|
*/
|
|
function createFirebaseNamespace() {
|
|
const namespace = createFirebaseNamespaceCore(FirebaseAppImpl);
|
|
namespace.INTERNAL = Object.assign(Object.assign({}, namespace.INTERNAL), { createFirebaseNamespace,
|
|
extendNamespace,
|
|
createSubscribe,
|
|
ErrorFactory,
|
|
deepExtend });
|
|
/**
|
|
* Patch the top-level firebase namespace with additional properties.
|
|
*
|
|
* firebase.INTERNAL.extendNamespace()
|
|
*/
|
|
function extendNamespace(props) {
|
|
deepExtend(namespace, props);
|
|
}
|
|
return namespace;
|
|
}
|
|
const firebase$1 = createFirebaseNamespace();
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
const logger = new Logger('@firebase/app-compat');
|
|
|
|
const name = "@firebase/app-compat";
|
|
const version = "0.2.1";
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
function registerCoreComponents(variant) {
|
|
// Register `app` package.
|
|
registerVersion(name, version, variant);
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
// Firebase Lite detection
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
if (isBrowser() && self.firebase !== undefined) {
|
|
logger.warn(`
|
|
Warning: Firebase is already defined in the global scope. Please make sure
|
|
Firebase library is only loaded once.
|
|
`);
|
|
// eslint-disable-next-line
|
|
const sdkVersion = self.firebase.SDK_VERSION;
|
|
if (sdkVersion && sdkVersion.indexOf('LITE') >= 0) {
|
|
logger.warn(`
|
|
Warning: You are trying to load Firebase while using Firebase Performance standalone script.
|
|
You should load Firebase Performance with this instance of Firebase to avoid loading duplicate code.
|
|
`);
|
|
}
|
|
}
|
|
const firebase = firebase$1;
|
|
registerCoreComponents();
|
|
|
|
export { firebase as default };
|
|
//# sourceMappingURL=index.esm2017.js.map
|