mirror of
https://github.com/musix-org/musix-oss
synced 2024-11-14 16:00:17 +00:00
542 lines
20 KiB
JavaScript
542 lines
20 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
|
|
|
var tslib_1 = require('tslib');
|
|
var util = require('@firebase/util');
|
|
var logger$1 = require('@firebase/logger');
|
|
var Storage = _interopDefault(require('dom-storage'));
|
|
var xmlhttprequest = require('xmlhttprequest');
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
var _a;
|
|
var ERRORS = (_a = {},
|
|
_a["no-app" /* NO_APP */] = "No Firebase App '{$appName}' has been created - " +
|
|
'call Firebase App.initializeApp()',
|
|
_a["bad-app-name" /* BAD_APP_NAME */] = "Illegal App name: '{$appName}",
|
|
_a["duplicate-app" /* DUPLICATE_APP */] = "Firebase App named '{$appName}' already exists",
|
|
_a["app-deleted" /* APP_DELETED */] = "Firebase App named '{$appName}' already deleted",
|
|
_a["invalid-app-argument" /* INVALID_APP_ARGUMENT */] = 'firebase.{$appName}() takes either no argument or a ' +
|
|
'Firebase App instance.',
|
|
_a);
|
|
var ERROR_FACTORY = new util.ErrorFactory('app', 'Firebase', ERRORS);
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
var DEFAULT_ENTRY_NAME = '[DEFAULT]';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
// An array to capture listeners before the true auth functions
|
|
// exist
|
|
var tokenListeners = [];
|
|
/**
|
|
* Global context object for a collection of services using
|
|
* a shared authentication state.
|
|
*/
|
|
var FirebaseAppImpl = /** @class */ (function () {
|
|
function FirebaseAppImpl(options, config, firebase_) {
|
|
this.firebase_ = firebase_;
|
|
this.isDeleted_ = false;
|
|
this.services_ = {};
|
|
this.name_ = config.name;
|
|
this.automaticDataCollectionEnabled_ =
|
|
config.automaticDataCollectionEnabled || false;
|
|
this.options_ = util.deepCopy(options);
|
|
this.INTERNAL = {
|
|
getUid: function () { return null; },
|
|
getToken: function () { return Promise.resolve(null); },
|
|
addAuthTokenListener: function (callback) {
|
|
tokenListeners.push(callback);
|
|
// Make sure callback is called, asynchronously, in the absence of the auth module
|
|
setTimeout(function () { return callback(null); }, 0);
|
|
},
|
|
removeAuthTokenListener: function (callback) {
|
|
tokenListeners = tokenListeners.filter(function (listener) { return listener !== callback; });
|
|
}
|
|
};
|
|
}
|
|
Object.defineProperty(FirebaseAppImpl.prototype, "automaticDataCollectionEnabled", {
|
|
get: function () {
|
|
this.checkDestroyed_();
|
|
return this.automaticDataCollectionEnabled_;
|
|
},
|
|
set: function (val) {
|
|
this.checkDestroyed_();
|
|
this.automaticDataCollectionEnabled_ = val;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FirebaseAppImpl.prototype, "name", {
|
|
get: function () {
|
|
this.checkDestroyed_();
|
|
return this.name_;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(FirebaseAppImpl.prototype, "options", {
|
|
get: function () {
|
|
this.checkDestroyed_();
|
|
return this.options_;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
FirebaseAppImpl.prototype.delete = function () {
|
|
var _this = this;
|
|
return new Promise(function (resolve) {
|
|
_this.checkDestroyed_();
|
|
resolve();
|
|
})
|
|
.then(function () {
|
|
_this.firebase_.INTERNAL.removeApp(_this.name_);
|
|
var services = [];
|
|
for (var _i = 0, _a = Object.keys(_this.services_); _i < _a.length; _i++) {
|
|
var serviceKey = _a[_i];
|
|
for (var _b = 0, _c = Object.keys(_this.services_[serviceKey]); _b < _c.length; _b++) {
|
|
var instanceKey = _c[_b];
|
|
services.push(_this.services_[serviceKey][instanceKey]);
|
|
}
|
|
}
|
|
return Promise.all(services
|
|
.filter(function (service) { return 'INTERNAL' in service; })
|
|
.map(function (service) { return service.INTERNAL.delete(); }));
|
|
})
|
|
.then(function () {
|
|
_this.isDeleted_ = true;
|
|
_this.services_ = {};
|
|
});
|
|
};
|
|
/**
|
|
* 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
|
|
*/
|
|
FirebaseAppImpl.prototype._getService = function (name, instanceIdentifier) {
|
|
if (instanceIdentifier === void 0) { instanceIdentifier = DEFAULT_ENTRY_NAME; }
|
|
this.checkDestroyed_();
|
|
if (!this.services_[name]) {
|
|
this.services_[name] = {};
|
|
}
|
|
if (!this.services_[name][instanceIdentifier]) {
|
|
/**
|
|
* If a custom instance has been defined (i.e. not '[DEFAULT]')
|
|
* then we will pass that instance on, otherwise we pass `null`
|
|
*/
|
|
var instanceSpecifier = instanceIdentifier !== DEFAULT_ENTRY_NAME
|
|
? instanceIdentifier
|
|
: undefined;
|
|
var service = this.firebase_.INTERNAL.factories[name](this, this.extendApp.bind(this), instanceSpecifier);
|
|
this.services_[name][instanceIdentifier] = service;
|
|
}
|
|
return this.services_[name][instanceIdentifier];
|
|
};
|
|
/**
|
|
* Remove a service instance from the cache, so we will create a new instance for this service
|
|
* when people try to get this service again.
|
|
*
|
|
* NOTE: currently only firestore is using this functionality to support firestore shutdown.
|
|
*
|
|
* @param name The service name
|
|
* @param instanceIdentifier instance identifier in case multiple instances are allowed
|
|
* @internal
|
|
*/
|
|
FirebaseAppImpl.prototype._removeServiceInstance = function (name, instanceIdentifier) {
|
|
if (instanceIdentifier === void 0) { instanceIdentifier = DEFAULT_ENTRY_NAME; }
|
|
if (this.services_[name] && this.services_[name][instanceIdentifier]) {
|
|
delete this.services_[name][instanceIdentifier];
|
|
}
|
|
};
|
|
/**
|
|
* Callback function used to extend an App instance at the time
|
|
* of service instance creation.
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
FirebaseAppImpl.prototype.extendApp = function (props) {
|
|
var _this = this;
|
|
// Copy the object onto the FirebaseAppImpl prototype
|
|
util.deepExtend(this, props);
|
|
/**
|
|
* If the app has overwritten the addAuthTokenListener stub, forward
|
|
* the active token listeners on to the true fxn.
|
|
*
|
|
* TODO: This function is required due to our current module
|
|
* structure. Once we are able to rely strictly upon a single module
|
|
* implementation, this code should be refactored and Auth should
|
|
* provide these stubs and the upgrade logic
|
|
*/
|
|
if (props.INTERNAL && props.INTERNAL.addAuthTokenListener) {
|
|
tokenListeners.forEach(function (listener) {
|
|
_this.INTERNAL.addAuthTokenListener(listener);
|
|
});
|
|
tokenListeners = [];
|
|
}
|
|
};
|
|
/**
|
|
* This function will throw an Error if the App has already been deleted -
|
|
* use before performing API actions on the App.
|
|
*/
|
|
FirebaseAppImpl.prototype.checkDestroyed_ = function () {
|
|
if (this.isDeleted_) {
|
|
throw ERROR_FACTORY.create("app-deleted" /* APP_DELETED */, { appName: this.name_ });
|
|
}
|
|
};
|
|
return FirebaseAppImpl;
|
|
}());
|
|
// Prevent dead-code elimination of these methods w/o invalid property
|
|
// copying.
|
|
(FirebaseAppImpl.prototype.name && FirebaseAppImpl.prototype.options) ||
|
|
FirebaseAppImpl.prototype.delete ||
|
|
console.log('dc');
|
|
|
|
var version = "6.6.0";
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
var logger = new logger$1.Logger('@firebase/app');
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google Inc.
|
|
*
|
|
* 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) {
|
|
var apps = {};
|
|
var factories = {};
|
|
var appHooks = {};
|
|
// A namespace is a plain JavaScript Object.
|
|
var namespace = {
|
|
// Hack to prevent Babel from modifying the object returned
|
|
// as the firebase namespace.
|
|
// @ts-ignore
|
|
__esModule: true,
|
|
initializeApp: initializeApp,
|
|
// @ts-ignore
|
|
app: app,
|
|
// @ts-ignore
|
|
apps: null,
|
|
SDK_VERSION: version,
|
|
INTERNAL: {
|
|
registerService: registerService,
|
|
removeApp: removeApp,
|
|
factories: factories,
|
|
useAsService: useAsService
|
|
}
|
|
};
|
|
// 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) {
|
|
var app = apps[name];
|
|
callAppHooks(app, 'delete');
|
|
delete apps[name];
|
|
}
|
|
/**
|
|
* Get the App object for a given name (or DEFAULT).
|
|
*/
|
|
function app(name) {
|
|
name = name || DEFAULT_ENTRY_NAME;
|
|
if (!util.contains(apps, name)) {
|
|
throw ERROR_FACTORY.create("no-app" /* NO_APP */, { appName: name });
|
|
}
|
|
return apps[name];
|
|
}
|
|
// @ts-ignore
|
|
app['App'] = firebaseAppImpl;
|
|
function initializeApp(options, rawConfig) {
|
|
if (rawConfig === void 0) { rawConfig = {}; }
|
|
if (typeof rawConfig !== 'object' || rawConfig === null) {
|
|
var name_1 = rawConfig;
|
|
rawConfig = { name: name_1 };
|
|
}
|
|
var config = rawConfig;
|
|
if (config.name === undefined) {
|
|
config.name = DEFAULT_ENTRY_NAME;
|
|
}
|
|
var name = config.name;
|
|
if (typeof name !== 'string' || !name) {
|
|
throw ERROR_FACTORY.create("bad-app-name" /* BAD_APP_NAME */, {
|
|
appName: String(name)
|
|
});
|
|
}
|
|
if (util.contains(apps, name)) {
|
|
throw ERROR_FACTORY.create("duplicate-app" /* DUPLICATE_APP */, { appName: name });
|
|
}
|
|
var app = new firebaseAppImpl(options, config, namespace);
|
|
apps[name] = app;
|
|
callAppHooks(app, 'create');
|
|
return app;
|
|
}
|
|
/*
|
|
* 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(function (name) { return apps[name]; });
|
|
}
|
|
/*
|
|
* Register a Firebase Service.
|
|
*
|
|
* firebase.INTERNAL.registerService()
|
|
*
|
|
* TODO: Implement serviceProperties.
|
|
*/
|
|
function registerService(name, createService, serviceProperties, appHook, allowMultipleInstances) {
|
|
if (allowMultipleInstances === void 0) { allowMultipleInstances = false; }
|
|
// If re-registering a service that already exists, return existing service
|
|
if (factories[name]) {
|
|
logger.debug("There were multiple attempts to register service " + name + ".");
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
return namespace[name];
|
|
}
|
|
// Capture the service factory for later service instantiation
|
|
factories[name] = createService;
|
|
// Capture the appHook, if passed
|
|
if (appHook) {
|
|
appHooks[name] = appHook;
|
|
// Run the **new** app hook on all existing apps
|
|
getApps().forEach(function (app) {
|
|
appHook('create', app);
|
|
});
|
|
}
|
|
// The Service namespace is an accessor function ...
|
|
function serviceNamespace(appArg) {
|
|
if (appArg === void 0) { appArg = app(); }
|
|
// @ts-ignore
|
|
if (typeof appArg[name] !== 'function') {
|
|
// Invalid argument.
|
|
// This happens in the following case: firebase.storage('gs:/')
|
|
throw ERROR_FACTORY.create("invalid-app-argument" /* INVALID_APP_ARGUMENT */, {
|
|
appName: name
|
|
});
|
|
}
|
|
// Forward service instance lookup to the FirebaseApp.
|
|
// @ts-ignore
|
|
return appArg[name]();
|
|
}
|
|
// ... and a container for service-level properties.
|
|
if (serviceProperties !== undefined) {
|
|
util.deepExtend(serviceNamespace, serviceProperties);
|
|
}
|
|
// Monkey-patch the serviceNamespace onto the firebase namespace
|
|
// @ts-ignore
|
|
namespace[name] = serviceNamespace;
|
|
// Patch the FirebaseAppImpl prototype
|
|
// @ts-ignore
|
|
firebaseAppImpl.prototype[name] =
|
|
// 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 () {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var serviceFxn = this._getService.bind(this, name);
|
|
return serviceFxn.apply(this, allowMultipleInstances ? args : []);
|
|
};
|
|
return serviceNamespace;
|
|
}
|
|
function callAppHooks(app, eventName) {
|
|
for (var _i = 0, _a = Object.keys(factories); _i < _a.length; _i++) {
|
|
var serviceName = _a[_i];
|
|
// Ignore virtual services
|
|
var factoryName = useAsService(app, serviceName);
|
|
if (factoryName === null) {
|
|
return;
|
|
}
|
|
if (appHooks[factoryName]) {
|
|
appHooks[factoryName](eventName, app);
|
|
}
|
|
}
|
|
}
|
|
// 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;
|
|
}
|
|
var useService = name;
|
|
return useService;
|
|
}
|
|
return namespace;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google Inc.
|
|
*
|
|
* 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() {
|
|
var namespace = createFirebaseNamespaceCore(FirebaseAppImpl);
|
|
namespace.INTERNAL = tslib_1.__assign({}, namespace.INTERNAL, { createFirebaseNamespace: createFirebaseNamespace,
|
|
extendNamespace: extendNamespace,
|
|
createSubscribe: util.createSubscribe,
|
|
ErrorFactory: util.ErrorFactory,
|
|
deepExtend: util.deepExtend });
|
|
/**
|
|
* Patch the top-level firebase namespace with additional properties.
|
|
*
|
|
* firebase.INTERNAL.extendNamespace()
|
|
*/
|
|
function extendNamespace(props) {
|
|
util.deepExtend(namespace, props);
|
|
}
|
|
return namespace;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google Inc.
|
|
*
|
|
* 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.
|
|
*/
|
|
var _firebase = createFirebaseNamespace();
|
|
_firebase.INTERNAL.extendNamespace({
|
|
INTERNAL: {
|
|
node: {
|
|
localStorage: new Storage(null, { strict: true }),
|
|
sessionStorage: new Storage(null, { strict: true }),
|
|
XMLHttpRequest: xmlhttprequest.XMLHttpRequest
|
|
}
|
|
}
|
|
});
|
|
var firebase = _firebase;
|
|
|
|
exports.default = firebase;
|
|
exports.firebase = firebase;
|
|
//# sourceMappingURL=index.node.cjs.js.map
|