Fixing dts file

common/api-review/firestore.api.md

@@ -216,8 +216,13 @@ export class FirestoreError extends FirebaseError {
 // @public
 export type FirestoreErrorCode = 'cancelled' | 'unknown' | 'invalid-argument' | 'deadline-exceeded' | 'not-found' | 'already-exists' | 'permission-denied' | 'resource-exhausted' | 'failed-precondition' | 'aborted' | 'out-of-range' | 'unimplemented' | 'internal' | 'unavailable' | 'data-loss' | 'unauthenticated';
 
+// @public (undocumented)
+export type FirestoreLocalCache = MemoryLocalCache | IndexedDbLocalCache;
+
 // @public
 export interface FirestoreSettings {
+    // (undocumented)
+    cache?: FirestoreLocalCache;
     cacheSizeBytes?: number;
     experimentalAutoDetectLongPolling?: boolean;
     experimentalForceLongPolling?: boolean;
@@ -285,6 +290,46 @@ export interface IndexConfiguration {
     readonly indexes?: Index[];
 }
 
+// @public (undocumented)
+export interface IndexedDbLocalCache {
+    // (undocumented)
+    kind: 'indexeddb';
+}
+
+// @public (undocumented)
+export function indexedDbLocalCache(settings?: IndexedDbSettings): IndexedDbLocalCache;
+
+// @public (undocumented)
+export interface IndexedDbMultipleTabManager {
+    // (undocumented)
+    kind: 'IndexedDbMultipleTab';
+}
+
+// @public (undocumented)
+export function indexedDbMultipleTabManager(): IndexedDbMultipleTabManager;
+
+// @public (undocumented)
+export interface IndexedDbSettings {
+    // (undocumented)
+    cacheSizeBytes?: number;
+    // (undocumented)
+    tabManager?: IndexedDbTabManager;
+}
+
+// @public (undocumented)
+export interface IndexedDbSingleTabManager {
+    // (undocumented)
+    kind: 'indexedDbSingleTab';
+}
+
+// @public (undocumented)
+export function indexedDbSingleTabManager(settings: {
+    forceOwnership?: boolean;
+} | undefined): IndexedDbSingleTabManager;
+
+// @public (undocumented)
+export type IndexedDbTabManager = IndexedDbSingleTabManager | IndexedDbMultipleTabManager;
+
 // @beta
 export interface IndexField {
     // (undocumented)
@@ -324,6 +369,15 @@ export interface LoadBundleTaskProgress {
 
 export { LogLevel }
 
+// @public (undocumented)
+export interface MemoryLocalCache {
+    // (undocumented)
+    kind: 'memory';
+}
+
+// @public (undocumented)
+export function memoryLocalCache(): MemoryLocalCache;
+
 // @public
 export function namedQuery(firestore: Firestore, name: string): Promise<Query | null>;
 

packages/firestore/src/api.ts

@@ -30,14 +30,14 @@ export {
 
 export {
   FirestoreLocalCache,
-  MemoryLocalCache,
   IndexedDbLocalCache,
   IndexedDbMultipleTabManager,
   indexedDbLocalCache,
   indexedDbMultipleTabManager,
   IndexedDbSettings,
   indexedDbSingleTabManager,
   IndexedDbSingleTabManager,
+  MemoryLocalCache,
   memoryLocalCache,
   IndexedDbTabManager
 } from './api/cache_config';

packages/firestore/src/api/cache_config.ts

@@ -23,15 +23,27 @@ import {
   OnlineComponentProvider
 } from '../core/component_provider';
 
-export interface MemoryLocalCache {
+export type MemoryLocalCache = {
   kind: 'memory';
+  /**
+   * @internal
+   */
   _onlineComponentProvider: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider: MemoryOfflineComponentProvider;
-}
+};
 
 class MemoryLocalCacheImpl implements MemoryLocalCache {
   kind: 'memory' = 'memory';
+  /**
+   * @internal
+   */
   _onlineComponentProvider: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider: MemoryOfflineComponentProvider;
 
   constructor() {
@@ -44,15 +56,27 @@ class MemoryLocalCacheImpl implements MemoryLocalCache {
   }
 }
 
-export interface IndexedDbLocalCache {
+export type IndexedDbLocalCache = {
   kind: 'indexeddb';
+  /**
+   * @internal
+   */
   _onlineComponentProvider: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider: OfflineComponentProvider;
-}
+};
 
 class IndexedDbLocalCacheImpl implements IndexedDbLocalCache {
   kind: 'indexeddb' = 'indexeddb';
+  /**
+   * @internal
+   */
   _onlineComponentProvider: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider: OfflineComponentProvider;
 
   constructor(settings: IndexedDbSettings | undefined) {
@@ -93,19 +117,34 @@ export function indexedDbLocalCache(
   return new IndexedDbLocalCacheImpl(settings);
 }
 
-export interface IndexedDbSingleTabManager {
+export type IndexedDbSingleTabManager = {
   kind: 'indexedDbSingleTab';
+  /**
+   * @internal
+   */
   _initialize: (
     settings: Omit<IndexedDbSettings, 'tabManager'> | undefined
   ) => void;
+  /**
+   * @internal
+   */
   _onlineComponentProvider?: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider?: OfflineComponentProvider;
-}
+};
 
 class SingleTabManagerImpl implements IndexedDbSingleTabManager {
   kind: 'indexedDbSingleTab' = 'indexedDbSingleTab';
 
+  /**
+   * @internal
+   */
   _onlineComponentProvider?: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider?: OfflineComponentProvider;
 
   constructor(private forceOwnership?: boolean) {}
@@ -114,6 +153,9 @@ class SingleTabManagerImpl implements IndexedDbSingleTabManager {
     return { kind: this.kind };
   }
 
+  /**
+   * @internal
+   */
   _initialize(
     settings: Omit<IndexedDbSettings, 'tabManager'> | undefined
   ): void {
@@ -126,23 +168,42 @@ class SingleTabManagerImpl implements IndexedDbSingleTabManager {
   }
 }
 
-export interface IndexedDbMultipleTabManager {
+export type IndexedDbMultipleTabManager = {
   kind: 'IndexedDbMultipleTab';
+  /**
+   * @internal
+   */
   _initialize: (settings: Omit<IndexedDbSettings, 'tabManager'>) => void;
+  /**
+   * @internal
+   */
   _onlineComponentProvider?: OnlineComponentProvider;
+  /**
+   * @internal
+   */
+
   _offlineComponentProvider?: OfflineComponentProvider;
-}
+};
 
 class MultiTabManagerImpl implements IndexedDbMultipleTabManager {
   kind: 'IndexedDbMultipleTab' = 'IndexedDbMultipleTab';
 
+  /**
+   * @internal
+   */
   _onlineComponentProvider?: OnlineComponentProvider;
+  /**
+   * @internal
+   */
   _offlineComponentProvider?: OfflineComponentProvider;
 
   toJSON(): {} {
     return { kind: this.kind };
   }
 
+  /**
+   * @internal
+   */
   _initialize(
     settings: Omit<IndexedDbSettings, 'tabManager'> | undefined
   ): void {

packages/firestore/src/api/database.ts

@@ -287,10 +287,10 @@ export function configureFirestore(firestore: Firestore): void {
     settings.cache?._offlineComponentProvider &&
     settings.cache?._onlineComponentProvider
   ) {
-    firestore._firestoreClient.uninitializedComponentsProvider = {
-      offlineKind: settings.cache.kind,
-      offline: settings.cache._offlineComponentProvider,
-      online: settings.cache._onlineComponentProvider
+    firestore._firestoreClient._uninitializedComponentsProvider = {
+      _offlineKind: settings.cache.kind,
+      _offline: settings.cache._offlineComponentProvider,
+      _online: settings.cache._onlineComponentProvider
     };
   }
 }
@@ -327,7 +327,7 @@ export function enableIndexedDbPersistence(
   verifyNotInitialized(firestore);
 
   const client = ensureFirestoreConfigured(firestore);
-  if (client.uninitializedComponentsProvider) {
+  if (client._uninitializedComponentsProvider) {
     throw new FirestoreError(
       Code.FAILED_PRECONDITION,
       'SDK cache is already specified.'
@@ -379,7 +379,7 @@ export function enableMultiTabIndexedDbPersistence(
   verifyNotInitialized(firestore);
 
   const client = ensureFirestoreConfigured(firestore);
-  if (client.uninitializedComponentsProvider) {
+  if (client._uninitializedComponentsProvider) {
     throw new FirestoreError(
       Code.FAILED_PRECONDITION,
       'SDK cache is already specified.'

packages/firestore/src/api/index_configuration.ts

@@ -151,8 +151,8 @@ export function setIndexConfiguration(
   firestore = cast(firestore, Firestore);
   const client = ensureFirestoreConfigured(firestore);
   if (
-    !client.uninitializedComponentsProvider ||
-    client.uninitializedComponentsProvider?.offlineKind === 'memory'
+    !client._uninitializedComponentsProvider ||
+    client._uninitializedComponentsProvider?._offlineKind === 'memory'
   ) {
     // PORTING NOTE: We don't return an error if the user has not enabled
     // persistence since `enableIndexeddbPersistence()` can fail on the Web.

packages/firestore/src/core/firestore_client.ts

@@ -114,14 +114,14 @@ export class FirestoreClient {
     appCheckToken: string,
     user: User
   ) => Promise<void> = () => Promise.resolve();
-  uninitializedComponentsProvider?: {
-    offline: OfflineComponentProvider;
-    offlineKind: 'memory' | 'indexeddb';
-    online: OnlineComponentProvider;
+  _uninitializedComponentsProvider?: {
+    _offline: OfflineComponentProvider;
+    _offlineKind: 'memory' | 'indexeddb';
+    _online: OnlineComponentProvider;
   };
 
-  offlineComponents?: OfflineComponentProvider;
-  onlineComponents?: OnlineComponentProvider;
+  _offlineComponents?: OfflineComponentProvider;
+  _onlineComponents?: OnlineComponentProvider;
 
   constructor(
     private authCredentials: CredentialsProvider<User>,
@@ -188,11 +188,11 @@ export class FirestoreClient {
     const deferred = new Deferred();
     this.asyncQueue.enqueueAndForgetEvenWhileRestricted(async () => {
       try {
-        if (this.onlineComponents) {
-          await this.onlineComponents.terminate();
+        if (this._onlineComponents) {
+          await this._onlineComponents.terminate();
         }
-        if (this.offlineComponents) {
-          await this.offlineComponents.terminate();
+        if (this._offlineComponents) {
+          await this._offlineComponents.terminate();
         }
 
         // The credentials provider must be terminated after shutting down the
@@ -240,7 +240,7 @@ export async function setOfflineComponentProvider(
     client.terminate()
   );
 
-  client.offlineComponents = offlineComponentProvider;
+  client._offlineComponents = offlineComponentProvider;
 }
 
 export async function setOnlineComponentProvider(
@@ -265,18 +265,18 @@ export async function setOnlineComponentProvider(
   client.setAppCheckTokenChangeListener((_, user) =>
     remoteStoreHandleCredentialChange(onlineComponentProvider.remoteStore, user)
   );
-  client.onlineComponents = onlineComponentProvider;
+  client._onlineComponents = onlineComponentProvider;
 }
 
 async function ensureOfflineComponents(
   client: FirestoreClient
 ): Promise<OfflineComponentProvider> {
-  if (!client.offlineComponents) {
-    if (client.uninitializedComponentsProvider) {
+  if (!client._offlineComponents) {
+    if (client._uninitializedComponentsProvider) {
       logDebug(LOG_TAG, 'Using user provided OfflineComponentProvider');
       await setOfflineComponentProvider(
         client,
-        client.uninitializedComponentsProvider.offline
+        client._uninitializedComponentsProvider._offline
       );
     } else {
       logDebug(LOG_TAG, 'Using default OfflineComponentProvider');
@@ -287,26 +287,26 @@ async function ensureOfflineComponents(
     }
   }
 
-  return client.offlineComponents!;
+  return client._offlineComponents!;
 }
 
 async function ensureOnlineComponents(
   client: FirestoreClient
 ): Promise<OnlineComponentProvider> {
-  if (!client.onlineComponents) {
-    if (client.uninitializedComponentsProvider) {
+  if (!client._onlineComponents) {
+    if (client._uninitializedComponentsProvider) {
       logDebug(LOG_TAG, 'Using user provided OnlineComponentProvider');
       await setOnlineComponentProvider(
         client,
-        client.uninitializedComponentsProvider.online
+        client._uninitializedComponentsProvider._online
       );
     } else {
       logDebug(LOG_TAG, 'Using default OnlineComponentProvider');
       await setOnlineComponentProvider(client, new OnlineComponentProvider());
     }
   }
 
-  return client.onlineComponents!;
+  return client._onlineComponents!;
 }
 
 function getPersistence(client: FirestoreClient): Promise<Persistence> {

packages/firestore/test/integration/util/helpers.ts

@@ -185,7 +185,6 @@ export async function withTestDbsSettings(
   const dbs: Firestore[] = [];
 
   for (let i = 0; i < numDbs; i++) {
-    // logWarn(`set persistence from helper: ${persistence}`);
     const newSettings = { ...settings };
     if (persistence) {
       newSettings.cache = indexedDbLocalCache();