bt-core-app 2.2.38 → 2.2.40

package/dist/bt-core/core/node_modules/@firebase/component/dist/esm/index.esm.mjs

@@ -0,0 +1,275 @@
+import { Deferred as h } from "../../../util/dist/index.esm.mjs";
+class I {
+  /**
+   *
+   * @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(e, t, n) {
+    this.name = e, this.instanceFactory = t, this.type = n, this.multipleInstances = !1, this.serviceProps = {}, this.instantiationMode = "LAZY", this.onInstanceCreated = null;
+  }
+  setInstantiationMode(e) {
+    return this.instantiationMode = e, this;
+  }
+  setMultipleInstances(e) {
+    return this.multipleInstances = e, this;
+  }
+  setServiceProps(e) {
+    return this.serviceProps = e, this;
+  }
+  setInstanceCreatedCallback(e) {
+    return this.onInstanceCreated = e, 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 a = "[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 l {
+  constructor(e, t) {
+    this.name = e, this.container = t, 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(e) {
+    const t = this.normalizeInstanceIdentifier(e);
+    if (!this.instancesDeferred.has(t)) {
+      const n = new h();
+      if (this.instancesDeferred.set(t, n), this.isInitialized(t) || this.shouldAutoInitialize())
+        try {
+          const i = this.getOrInitializeService({
+            instanceIdentifier: t
+          });
+          i && n.resolve(i);
+        } catch {
+        }
+    }
+    return this.instancesDeferred.get(t).promise;
+  }
+  getImmediate(e) {
+    const t = this.normalizeInstanceIdentifier(e == null ? void 0 : e.identifier), n = (e == null ? void 0 : e.optional) ?? !1;
+    if (this.isInitialized(t) || this.shouldAutoInitialize())
+      try {
+        return this.getOrInitializeService({
+          instanceIdentifier: t
+        });
+      } catch (i) {
+        if (n)
+          return null;
+        throw i;
+      }
+    else {
+      if (n)
+        return null;
+      throw Error(`Service ${this.name} is not available`);
+    }
+  }
+  getComponent() {
+    return this.component;
+  }
+  setComponent(e) {
+    if (e.name !== this.name)
+      throw Error(`Mismatching Component ${e.name} for Provider ${this.name}.`);
+    if (this.component)
+      throw Error(`Component for ${this.name} has already been provided`);
+    if (this.component = e, !!this.shouldAutoInitialize()) {
+      if (f(e))
+        try {
+          this.getOrInitializeService({ instanceIdentifier: a });
+        } catch {
+        }
+      for (const [t, n] of this.instancesDeferred.entries()) {
+        const i = this.normalizeInstanceIdentifier(t);
+        try {
+          const r = this.getOrInitializeService({
+            instanceIdentifier: i
+          });
+          n.resolve(r);
+        } catch {
+        }
+      }
+    }
+  }
+  clearInstance(e = a) {
+    this.instancesDeferred.delete(e), this.instancesOptions.delete(e), this.instances.delete(e);
+  }
+  // app.delete() will call this method on every provider to delete the services
+  // TODO: should we mark the provider as deleted?
+  async delete() {
+    const e = Array.from(this.instances.values());
+    await Promise.all([
+      ...e.filter((t) => "INTERNAL" in t).map((t) => t.INTERNAL.delete()),
+      ...e.filter((t) => "_delete" in t).map((t) => t._delete())
+    ]);
+  }
+  isComponentSet() {
+    return this.component != null;
+  }
+  isInitialized(e = a) {
+    return this.instances.has(e);
+  }
+  getOptions(e = a) {
+    return this.instancesOptions.get(e) || {};
+  }
+  initialize(e = {}) {
+    const { options: t = {} } = e, n = this.normalizeInstanceIdentifier(e.instanceIdentifier);
+    if (this.isInitialized(n))
+      throw Error(`${this.name}(${n}) has already been initialized`);
+    if (!this.isComponentSet())
+      throw Error(`Component ${this.name} has not been registered yet`);
+    const i = this.getOrInitializeService({
+      instanceIdentifier: n,
+      options: t
+    });
+    for (const [r, o] of this.instancesDeferred.entries()) {
+      const c = this.normalizeInstanceIdentifier(r);
+      n === c && o.resolve(i);
+    }
+    return i;
+  }
+  /**
+   *
+   * @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(e, t) {
+    const n = this.normalizeInstanceIdentifier(t), i = this.onInitCallbacks.get(n) ?? /* @__PURE__ */ new Set();
+    i.add(e), this.onInitCallbacks.set(n, i);
+    const r = this.instances.get(n);
+    return r && e(r, n), () => {
+      i.delete(e);
+    };
+  }
+  /**
+   * Invoke onInit callbacks synchronously
+   * @param instance the service instance`
+   */
+  invokeOnInitCallbacks(e, t) {
+    const n = this.onInitCallbacks.get(t);
+    if (n)
+      for (const i of n)
+        try {
+          i(e, t);
+        } catch {
+        }
+  }
+  getOrInitializeService({ instanceIdentifier: e, options: t = {} }) {
+    let n = this.instances.get(e);
+    if (!n && this.component && (n = this.component.instanceFactory(this.container, {
+      instanceIdentifier: d(e),
+      options: t
+    }), this.instances.set(e, n), this.instancesOptions.set(e, t), this.invokeOnInitCallbacks(n, e), this.component.onInstanceCreated))
+      try {
+        this.component.onInstanceCreated(this.container, e, n);
+      } catch {
+      }
+    return n || null;
+  }
+  normalizeInstanceIdentifier(e = a) {
+    return this.component ? this.component.multipleInstances ? e : a : e;
+  }
+  shouldAutoInitialize() {
+    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+  }
+}
+function d(s) {
+  return s === a ? void 0 : s;
+}
+function f(s) {
+  return s.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 u {
+  constructor(e) {
+    this.name = e, 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(e) {
+    const t = this.getProvider(e.name);
+    if (t.isComponentSet())
+      throw new Error(`Component ${e.name} has already been registered with ${this.name}`);
+    t.setComponent(e);
+  }
+  addOrOverwriteComponent(e) {
+    this.getProvider(e.name).isComponentSet() && this.providers.delete(e.name), this.addComponent(e);
+  }
+  /**
+   * 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(e) {
+    if (this.providers.has(e))
+      return this.providers.get(e);
+    const t = new l(e, this);
+    return this.providers.set(e, t), t;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+}
+export {
+  I as Component,
+  u as ComponentContainer,
+  l as Provider
+};