diff options
Diffstat (limited to 'frontend-old/node_modules/@firebase/component/dist/src')
5 files changed, 248 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@firebase/component/dist/src/component.d.ts b/frontend-old/node_modules/@firebase/component/dist/src/component.d.ts new file mode 100644 index 0000000..debdf77 --- /dev/null +++ b/frontend-old/node_modules/@firebase/component/dist/src/component.d.ts @@ -0,0 +1,43 @@ +/** + * @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 { InstantiationMode, InstanceFactory, ComponentType, Dictionary, Name, onInstanceCreatedCallback } from './types'; +/** + * Component for service name T, e.g. `auth`, `auth-internal` + */ +export declare class Component<T extends Name = Name> { + readonly name: T; + readonly instanceFactory: InstanceFactory<T>; + readonly type: ComponentType; + multipleInstances: boolean; + /** + * Properties to be added to the service namespace + */ + serviceProps: Dictionary; + instantiationMode: InstantiationMode; + onInstanceCreated: onInstanceCreatedCallback<T> | null; + /** + * + * @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: T, instanceFactory: InstanceFactory<T>, type: ComponentType); + setInstantiationMode(mode: InstantiationMode): this; + setMultipleInstances(multipleInstances: boolean): this; + setServiceProps(props: Dictionary): this; + setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this; +} diff --git a/frontend-old/node_modules/@firebase/component/dist/src/component_container.d.ts b/frontend-old/node_modules/@firebase/component/dist/src/component_container.d.ts new file mode 100644 index 0000000..a1322f3 --- /dev/null +++ b/frontend-old/node_modules/@firebase/component/dist/src/component_container.d.ts @@ -0,0 +1,47 @@ +/** + * @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 { Provider } from './provider'; +import { Component } from './component'; +import { Name } from './types'; +/** + * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal` + */ +export declare class ComponentContainer { + private readonly name; + private readonly providers; + constructor(name: string); + /** + * + * @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<T extends Name>(component: Component<T>): void; + addOrOverwriteComponent<T extends Name>(component: Component<T>): void; + /** + * 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<T extends Name>(name: T): Provider<T>; + getProviders(): Array<Provider<Name>>; +} diff --git a/frontend-old/node_modules/@firebase/component/dist/src/constants.d.ts b/frontend-old/node_modules/@firebase/component/dist/src/constants.d.ts new file mode 100644 index 0000000..b069f4e --- /dev/null +++ b/frontend-old/node_modules/@firebase/component/dist/src/constants.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 const DEFAULT_ENTRY_NAME = "[DEFAULT]"; diff --git a/frontend-old/node_modules/@firebase/component/dist/src/provider.d.ts b/frontend-old/node_modules/@firebase/component/dist/src/provider.d.ts new file mode 100644 index 0000000..8039aff --- /dev/null +++ b/frontend-old/node_modules/@firebase/component/dist/src/provider.d.ts @@ -0,0 +1,79 @@ +/** + * @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 './component_container'; +import { InitializeOptions, Name, NameServiceMapping, OnInitCallBack } from './types'; +import { Component } from './component'; +/** + * Provider for instance for service name T, e.g. 'auth', 'auth-internal' + * NameServiceMapping[T] is an alias for the type of the instance + */ +export declare class Provider<T extends Name> { + private readonly name; + private readonly container; + private component; + private readonly instances; + private readonly instancesDeferred; + private readonly instancesOptions; + private onInitCallbacks; + constructor(name: T, container: ComponentContainer); + /** + * @param identifier A provider can provide multiple instances of a service + * if this.component.multipleInstances is true. + */ + get(identifier?: string): Promise<NameServiceMapping[T]>; + /** + * + * @param options.identifier A provider can provide multiple instances of a service + * if this.component.multipleInstances is true. + * @param options.optional If optional is false or not provided, the method throws an error when + * the service is not immediately available. + * If optional is true, the method returns null if the service is not immediately available. + */ + getImmediate(options: { + identifier?: string; + optional: true; + }): NameServiceMapping[T] | null; + getImmediate(options?: { + identifier?: string; + optional?: false; + }): NameServiceMapping[T]; + getComponent(): Component<T> | null; + setComponent(component: Component<T>): void; + clearInstance(identifier?: string): void; + delete(): Promise<void>; + isComponentSet(): boolean; + isInitialized(identifier?: string): boolean; + getOptions(identifier?: string): Record<string, unknown>; + initialize(opts?: InitializeOptions): NameServiceMapping[T]; + /** + * + * @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: OnInitCallBack<T>, identifier?: string): () => void; + /** + * Invoke onInit callbacks synchronously + * @param instance the service instance` + */ + private invokeOnInitCallbacks; + private getOrInitializeService; + private normalizeInstanceIdentifier; + private shouldAutoInitialize; +} diff --git a/frontend-old/node_modules/@firebase/component/dist/src/types.d.ts b/frontend-old/node_modules/@firebase/component/dist/src/types.d.ts new file mode 100644 index 0000000..40eac68 --- /dev/null +++ b/frontend-old/node_modules/@firebase/component/dist/src/types.d.ts @@ -0,0 +1,62 @@ +/** + * @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 './component_container'; +export declare const enum InstantiationMode { + LAZY = "LAZY",// Currently most components are LAZY in JS SDK + EAGER = "EAGER",// EAGER components are initialized immediately upon registration + EXPLICIT = "EXPLICIT" +} +/** + * PUBLIC: A public component provides a set of public APIs to customers. A service namespace will be patched + * onto `firebase` namespace. Assume the component name is `test`, customers will be able + * to get the service by calling `firebase.test()` or `app.test()` where `app` is a `FirebaseApp` instance. + * + * PRIVATE: A private component provides a set of private APIs that are used internally by other + * Firebase SDKs. No service namespace is created in `firebase` namespace and customers have no way to get them. + */ +export declare const enum ComponentType { + PUBLIC = "PUBLIC", + PRIVATE = "PRIVATE", + VERSION = "VERSION" +} +export interface InstanceFactoryOptions { + instanceIdentifier?: string; + options?: {}; +} +export type InitializeOptions = InstanceFactoryOptions; +/** + * Factory to create an instance of type T, given a ComponentContainer. + * ComponentContainer is the IOC container that provides {@link Provider} + * for dependencies. + * + * NOTE: The container only provides {@link Provider} rather than the actual instances of dependencies. + * It is useful for lazily loaded dependencies and optional dependencies. + */ +export type InstanceFactory<T extends Name> = (container: ComponentContainer, options: InstanceFactoryOptions) => NameServiceMapping[T]; +export type onInstanceCreatedCallback<T extends Name> = (container: ComponentContainer, instanceIdentifier: string, instance: NameServiceMapping[T]) => void; +export interface Dictionary { + [key: string]: unknown; +} +/** + * This interface will be extended by Firebase SDKs to provide service name and service type mapping. + * It is used as a generic constraint to ensure type safety. + */ +export interface NameServiceMapping { +} +export type Name = keyof NameServiceMapping; +export type Service = NameServiceMapping[Name]; +export type OnInitCallBack<T extends Name> = (instance: NameServiceMapping[T], identifier: string) => void; |