@progressive-development/pd-spa-helper 0.3.104 → 0.5.0

package/dist/node_modules/@firebase/component/dist/esm/index.esm2017.js

@@ -1,341 +0,0 @@
-import { Deferred } from "../../../util/dist/index.esm2017.js";
-class Component {
-  /**
-   *
-   * @param name The public service name, e.g. app, auth, firestore, database
-   * @param instanceFactory Service factory responsible for creating the public interface
-   * @param type whether the service provided by the component is public or private
-   */
-  constructor(name, instanceFactory, type) {
-    this.name = name;
-    this.instanceFactory = instanceFactory;
-    this.type = type;
-    this.multipleInstances = false;
-    this.serviceProps = {};
-    this.instantiationMode = "LAZY";
-    this.onInstanceCreated = null;
-  }
-  setInstantiationMode(mode) {
-    this.instantiationMode = mode;
-    return this;
-  }
-  setMultipleInstances(multipleInstances) {
-    this.multipleInstances = multipleInstances;
-    return this;
-  }
-  setServiceProps(props) {
-    this.serviceProps = props;
-    return this;
-  }
-  setInstanceCreatedCallback(callback) {
-    this.onInstanceCreated = callback;
-    return this;
-  }
-}
-/**
- * @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 DEFAULT_ENTRY_NAME = "[DEFAULT]";
-/**
- * @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.
- */
-class Provider {
-  constructor(name, container) {
-    this.name = name;
-    this.container = container;
-    this.component = null;
-    this.instances = /* @__PURE__ */ new Map();
-    this.instancesDeferred = /* @__PURE__ */ new Map();
-    this.instancesOptions = /* @__PURE__ */ new Map();
-    this.onInitCallbacks = /* @__PURE__ */ new Map();
-  }
-  /**
-   * @param identifier A provider can provide multiple instances of a service
-   * if this.component.multipleInstances is true.
-   */
-  get(identifier) {
-    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
-    if (!this.instancesDeferred.has(normalizedIdentifier)) {
-      const deferred = new Deferred();
-      this.instancesDeferred.set(normalizedIdentifier, deferred);
-      if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
-        try {
-          const instance = this.getOrInitializeService({
-            instanceIdentifier: normalizedIdentifier
-          });
-          if (instance) {
-            deferred.resolve(instance);
-          }
-        } catch (e) {
-        }
-      }
-    }
-    return this.instancesDeferred.get(normalizedIdentifier).promise;
-  }
-  getImmediate(options) {
-    var _a;
-    const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);
-    const optional = (_a = options === null || options === void 0 ? void 0 : options.optional) !== null && _a !== void 0 ? _a : false;
-    if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
-      try {
-        return this.getOrInitializeService({
-          instanceIdentifier: normalizedIdentifier
-        });
-      } catch (e) {
-        if (optional) {
-          return null;
-        } else {
-          throw e;
-        }
-      }
-    } else {
-      if (optional) {
-        return null;
-      } else {
-        throw Error(`Service ${this.name} is not available`);
-      }
-    }
-  }
-  getComponent() {
-    return this.component;
-  }
-  setComponent(component) {
-    if (component.name !== this.name) {
-      throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
-    }
-    if (this.component) {
-      throw Error(`Component for ${this.name} has already been provided`);
-    }
-    this.component = component;
-    if (!this.shouldAutoInitialize()) {
-      return;
-    }
-    if (isComponentEager(component)) {
-      try {
-        this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });
-      } catch (e) {
-      }
-    }
-    for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
-      const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
-      try {
-        const instance = this.getOrInitializeService({
-          instanceIdentifier: normalizedIdentifier
-        });
-        instanceDeferred.resolve(instance);
-      } catch (e) {
-      }
-    }
-  }
-  clearInstance(identifier = DEFAULT_ENTRY_NAME) {
-    this.instancesDeferred.delete(identifier);
-    this.instancesOptions.delete(identifier);
-    this.instances.delete(identifier);
-  }
-  // app.delete() will call this method on every provider to delete the services
-  // TODO: should we mark the provider as deleted?
-  async delete() {
-    const services = Array.from(this.instances.values());
-    await Promise.all([
-      ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
-      ...services.filter((service) => "_delete" in service).map((service) => service._delete())
-    ]);
-  }
-  isComponentSet() {
-    return this.component != null;
-  }
-  isInitialized(identifier = DEFAULT_ENTRY_NAME) {
-    return this.instances.has(identifier);
-  }
-  getOptions(identifier = DEFAULT_ENTRY_NAME) {
-    return this.instancesOptions.get(identifier) || {};
-  }
-  initialize(opts = {}) {
-    const { options = {} } = opts;
-    const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
-    if (this.isInitialized(normalizedIdentifier)) {
-      throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
-    }
-    if (!this.isComponentSet()) {
-      throw Error(`Component ${this.name} has not been registered yet`);
-    }
-    const instance = this.getOrInitializeService({
-      instanceIdentifier: normalizedIdentifier,
-      options
-    });
-    for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
-      const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
-      if (normalizedIdentifier === normalizedDeferredIdentifier) {
-        instanceDeferred.resolve(instance);
-      }
-    }
-    return instance;
-  }
-  /**
-   *
-   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().
-   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.
-   *
-   * @param identifier An optional instance identifier
-   * @returns a function to unregister the callback
-   */
-  onInit(callback, identifier) {
-    var _a;
-    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
-    const existingCallbacks = (_a = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a !== void 0 ? _a : /* @__PURE__ */ new Set();
-    existingCallbacks.add(callback);
-    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
-    const existingInstance = this.instances.get(normalizedIdentifier);
-    if (existingInstance) {
-      callback(existingInstance, normalizedIdentifier);
-    }
-    return () => {
-      existingCallbacks.delete(callback);
-    };
-  }
-  /**
-   * Invoke onInit callbacks synchronously
-   * @param instance the service instance`
-   */
-  invokeOnInitCallbacks(instance, identifier) {
-    const callbacks = this.onInitCallbacks.get(identifier);
-    if (!callbacks) {
-      return;
-    }
-    for (const callback of callbacks) {
-      try {
-        callback(instance, identifier);
-      } catch (_a) {
-      }
-    }
-  }
-  getOrInitializeService({ instanceIdentifier, options = {} }) {
-    let instance = this.instances.get(instanceIdentifier);
-    if (!instance && this.component) {
-      instance = this.component.instanceFactory(this.container, {
-        instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
-        options
-      });
-      this.instances.set(instanceIdentifier, instance);
-      this.instancesOptions.set(instanceIdentifier, options);
-      this.invokeOnInitCallbacks(instance, instanceIdentifier);
-      if (this.component.onInstanceCreated) {
-        try {
-          this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
-        } catch (_a) {
-        }
-      }
-    }
-    return instance || null;
-  }
-  normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME) {
-    if (this.component) {
-      return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;
-    } else {
-      return identifier;
-    }
-  }
-  shouldAutoInitialize() {
-    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
-  }
-}
-function normalizeIdentifierForFactory(identifier) {
-  return identifier === DEFAULT_ENTRY_NAME ? void 0 : identifier;
-}
-function isComponentEager(component) {
-  return component.instantiationMode === "EAGER";
-}
-/**
- * @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.
- */
-class ComponentContainer {
-  constructor(name) {
-    this.name = name;
-    this.providers = /* @__PURE__ */ new Map();
-  }
-  /**
-   *
-   * @param component Component being added
-   * @param overwrite When a component with the same name has already been registered,
-   * if overwrite is true: overwrite the existing component with the new component and create a new
-   * provider with the new component. It can be useful in tests where you want to use different mocks
-   * for different tests.
-   * if overwrite is false: throw an exception
-   */
-  addComponent(component) {
-    const provider = this.getProvider(component.name);
-    if (provider.isComponentSet()) {
-      throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
-    }
-    provider.setComponent(component);
-  }
-  addOrOverwriteComponent(component) {
-    const provider = this.getProvider(component.name);
-    if (provider.isComponentSet()) {
-      this.providers.delete(component.name);
-    }
-    this.addComponent(component);
-  }
-  /**
-   * getProvider provides a type safe interface where it can only be called with a field name
-   * present in NameServiceMapping interface.
-   *
-   * Firebase SDKs providing services should extend NameServiceMapping interface to register
-   * themselves.
-   */
-  getProvider(name) {
-    if (this.providers.has(name)) {
-      return this.providers.get(name);
-    }
-    const provider = new Provider(name, this);
-    this.providers.set(name, provider);
-    return provider;
-  }
-  getProviders() {
-    return Array.from(this.providers.values());
-  }
-}
-export {
-  Component,
-  ComponentContainer,
-  Provider
-};