Revert extraneous changes

Author: hsubox76

common/api-review/functions-exp.api.md

@@ -4,7 +4,7 @@
 
 ```ts
 
-import { FirebaseApp } from '@firebase/app';
+import { FirebaseApp } from '@firebase/app-exp';
 import { FirebaseError } from '@firebase/util';
 
 // @public

packages-exp/functions-compat/src/index.ts

@@ -15,43 +15,22 @@
  * limitations under the License.
  */
 
-import firebase, {
-  FirebaseApp as FirebaseAppCompat
-} from '@firebase/app-compat';
+import firebase from '@firebase/app-compat';
 import { name, version } from '../package.json';
 import { registerFunctions } from './register';
-import { FirebaseFunctions as FunctionsCompat } from '@firebase/functions-types';
-import { Functions as FirebaseFunctionsExp } from '@firebase/functions-exp';
+import * as types from '@firebase/functions-types';
 
-declare module '@firebase/functions-exp' {
-  export function getFunctions(
-    app: FirebaseAppCompat,
-    regionOrCustomDomain?: string
-  ): FirebaseFunctionsExp;
-
-  export function httpsCallable<RequestData = unknown, ResponseData = unknown>(
-    functionsInstance: FunctionsCompat,
-    name: string,
-    options?: HttpsCallableOptions
-  ): HttpsCallable<RequestData, ResponseData>;
-
-  export function useFunctionsEmulator(
-    functionsInstance: FunctionsCompat,
-    host: string,
-    port: number
-  ): void;
-}
 registerFunctions();
 firebase.registerVersion(name, version);
 
 declare module '@firebase/app-compat' {
   interface FirebaseNamespace {
     functions?: {
-      (app?: FirebaseApp): FunctionsCompat;
-      Functions: typeof FunctionsCompat;
+      (app?: FirebaseApp): types.FirebaseFunctions;
+      Functions: typeof types.FirebaseFunctions;
     };
   }
   interface FirebaseApp {
-    functions?(regionOrCustomDomain?: string): FunctionsCompat;
+    functions?(regionOrCustomDomain?: string): types.FirebaseFunctions;
   }
 }

packages-exp/functions-compat/test/interop.test.ts

@@ -38,4 +38,3 @@ export * from './src/utf8';
 export * from './src/exponential_backoff';
 export * from './src/formatters';
 export * from './src/compat';
-export * from './src/exp';

packages/util/index.node.ts

@@ -33,4 +33,3 @@ export * from './src/utf8';
 export * from './src/exponential_backoff';
 export * from './src/formatters';
 export * from './src/compat';
-export * from './src/exp';

packages/util/index.ts

@@ -34,111 +34,62 @@ export function getImportPathTransformer({ pattern, template }) {
 export const importPathTransformer = () => ({
   before: [
     transformImportPath({
-      pattern: /^(@firebase.*)-exp(.*)$/,
+      pattern: /^(@firebase.*)-exp(.*)$/g,
       template: [1, 2]
     })
   ],
   after: [],
   afterDeclarations: [
     transformImportPath({
-      pattern: /^(@firebase.*)-exp(.*)$/,
+      pattern: /^(@firebase.*)-exp(.*)$/g,
       template: [1, 2]
     })
   ]
 });
 
 function transformImportPath({ pattern, template }) {
   return context => file => {
-    return visitNodeAndChildren(
-      file,
-      context,
-      { pattern, template },
-      transformNode
-    );
+    return visitNodeAndChildren(file, context, { pattern, template });
   };
 }
 
-function visitNodeAndChildren(
-  node,
-  context,
-  { pattern, template },
-  nodeTransformer
-) {
+function visitNodeAndChildren(node, context, { pattern, template }) {
   return ts.visitEachChild(
-    nodeTransformer(node, { pattern, template }),
+    visitNode(node, { pattern, template }),
     childNode =>
-      visitNodeAndChildren(
-        childNode,
-        context,
-        { pattern, template },
-        nodeTransformer
-      ),
+      visitNodeAndChildren(childNode, context, { pattern, template }),
     context
   );
 }
 
-function replacePath(pathString, pattern, template) {
-  const pathStringWithoutQuotes = pathString.substr(1, pathString.length - 2);
-
-  const captures = pattern.exec(pathStringWithoutQuotes);
-
-  if (captures) {
-    const newNameFragments = [];
-    for (const fragment of template) {
-      if (typeof fragment === 'number') {
-        newNameFragments.push(captures[fragment]);
-      } else if (typeof fragment === 'string') {
-        newNameFragments.push(fragment);
-      } else {
-        throw Error(`unrecognized fragment: ${fragment}`);
-      }
-    }
-    return newNameFragments.join('');
-  }
-
-  return null;
-}
-
-function transformNode(node, { pattern, template }) {
+function visitNode(node, { pattern, template }) {
+  let importPath;
   if (
     (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
     node.moduleSpecifier
   ) {
     const importPathWithQuotes = node.moduleSpecifier.getText();
-    const newName = replacePath(importPathWithQuotes, pattern, template);
+    importPath = importPathWithQuotes.substr(
+      1,
+      importPathWithQuotes.length - 2
+    );
+
+    const captures = pattern.exec(importPath);
 
-    if (newName) {
-      if (ts.isImportDeclaration(node)) {
-        return ts.factory.updateImportDeclaration(
-          node,
-          node.decorators,
-          node.modifiers,
-          node.importClause,
-          ts.factory.createStringLiteral(newName) // moduleSpecifier
-        );
-      } else if (ts.isExportDeclaration(node)) {
-        return ts.factory.updateExportDeclaration(
-          node,
-          node.decorators,
-          node.modifiers,
-          node.isTypeOnly,
-          node.exportClause,
-          ts.factory.createStringLiteral(newName) // moduleSpecifier
-        );
+    if (captures) {
+      const newNameFragments = [];
+      for (const fragment of template) {
+        if (typeof fragment === 'number') {
+          newNameFragments.push(captures[fragment]);
+        } else if (typeof fragment === 'string') {
+          newNameFragments.push(fragment);
+        } else {
+          throw Error(`unrecognized fragment: ${fragment}`);
+        }
       }
-      // Just in case.
-      return node;
-    }
-  } else if (ts.isModuleDeclaration(node) && node.name) {
-    const importPathWithQuotes = node.name.getText();
-    const newName = replacePath(importPathWithQuotes, pattern, template);
-    if (newName) {
-      const newNode = ts.factory.updateModuleDeclaration(
-        node,
-        node.decorators,
-        node.modifiers,
-        ts.factory.createStringLiteral(newName) // name
-      );
+      const newName = newNameFragments.join('');
+      const newNode = ts.getMutableClone(node);
+      newNode.moduleSpecifier = ts.createLiteral(newName);
       return newNode;
     }
   }