Remove react-packager indirection.

Summary:
This moves the `src` directory one level up and removes the `react-packager` folder. Personally, I always disliked this indirection. I'm reorganizing some things in RNP, so this seems to make sense.

Not sure if I forgot to update any paths. Can anyone advice if there are more places that need change?

Reviewed By: jeanlauliac

Differential Revision: D4487867

fbshipit-source-id: d63f9c79d6238300df9632d2e6a4e6a4196d5ccb

packager/src/ModuleGraph/output/__tests__/util-test.js

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+'use strict';
+
+jest.disableAutomock();
+
+const {match} = require('sinon');
+const {fn} = require('../../test-helpers');
+const {
+  addModuleIdsToModuleWrapper,
+  createIdForPathFn,
+} = require('../util');
+
+const {any} = jasmine;
+
+describe('`addModuleIdsToModuleWrapper`:', () => {
+  const path = 'path/to/file';
+  const createModule = (dependencies = []) => ({
+    dependencies,
+    file: {code: '__d(function(){});', isModule: true, path},
+  });
+
+  it('completes the module wrapped with module ID, and an array of dependency IDs', () => {
+    const dependencies = [
+      {id: 'a', path: 'path/to/a.js'},
+      {id: 'b', path: 'location/of/b.js'},
+    ];
+    const module = createModule(dependencies);
+
+    const idForPath = fn();
+    idForPath.stub
+      .withArgs(match({path})).returns(12)
+      .withArgs(match({path: dependencies[0].path})).returns(345)
+      .withArgs(match({path: dependencies[1].path})).returns(6);
+
+    expect(addModuleIdsToModuleWrapper(module, idForPath))
+      .toEqual('__d(function(){},12,[345,6]);');
+  });
+
+  it('omits the array of dependency IDs if it is empty', () => {
+    const module = createModule();
+    expect(addModuleIdsToModuleWrapper(module, () => 98))
+      .toEqual(`__d(function(){},${98});`);
+  });
+});
+
+describe('`createIdForPathFn`', () => {
+  let idForPath;
+  beforeEach(() => {
+    idForPath = createIdForPathFn();
+  });
+
+  it('returns a number for a string', () => {
+    expect(idForPath({path: 'arbitrary'})).toEqual(any(Number));
+  });
+
+  it('returns consecutive numbers', () => {
+    const strings = [
+      'arbitrary string',
+      'looking/like/a/path',
+      '/absolute/path/to/file.js',
+      '/more files/are here',
+    ];
+
+    strings.forEach((string, i) => {
+      expect(idForPath({path: string})).toEqual(i);
+    });
+  });
+
+  it('returns the same id if the same string is passed in again', () => {
+    const path = 'this/is/an/arbitrary/path.js';
+    const id = idForPath({path});
+    idForPath({path: '/other/file'});
+    idForPath({path: 'and/another/file'});
+    expect(idForPath({path})).toEqual(id);
+  });
+});

packager/src/ModuleGraph/output/as-plain-bundle.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ */
+'use strict';
+
+const {createIndexMap} = require('./source-map');
+const {addModuleIdsToModuleWrapper} = require('./util');
+
+import type {OutputFn} from '../types.flow';
+
+module.exports = (
+  (modules, filename, idForPath) => {
+    let code = '';
+    let line = 0;
+    const sections = [];
+
+    for (const module of modules) {
+      const {file} = module;
+      const moduleCode = file.type === 'module'
+        ? addModuleIdsToModuleWrapper(module, idForPath)
+        : file.code;
+
+      code += moduleCode + '\n';
+      if (file.map) {
+        sections.push({
+          map: file.map,
+          offset: {column: 0, line}
+        });
+      }
+      line += countLines(moduleCode);
+    }
+
+    return {code, map: createIndexMap({file: filename, sections})};
+  }: OutputFn);
+
+const reLine = /^/gm;
+function countLines(string: string): number {
+  //$FlowFixMe This regular expression always matches
+  return string.match(reLine).length;
+}

packager/src/ModuleGraph/output/source-map.js

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ */
+'use strict';
+
+type CreateIndexMapOptions = {|
+  file?: string,
+  sections?: Array<IndexMapSection>
+|};
+
+type IndexMap = MapBase & {
+  sections: Array<IndexMapSection>,
+};
+
+type IndexMapSection = {
+  map: IndexMap | MappingsMap,
+  offset: {line: number, column: number},
+};
+
+type MapBase = {
+  // always the first entry in the source map entry object per
+  // https://fburl.com/source-map-spec#heading=h.qz3o9nc69um5
+  version: 3,
+  file?: string,
+};
+
+type MappingsMap = MapBase & {
+  mappings: string,
+  names: Array<string>,
+  sourceRoot?: string,
+  sources: Array<string>,
+  sourcesContent?: Array<?string>,
+};
+
+export type SourceMap = IndexMap | MappingsMap;
+
+exports.createIndexMap = (opts?: CreateIndexMapOptions): IndexMap => ({
+  version: 3,
+  file: opts && opts.file,
+  sections: opts && opts.sections || [],
+});

packager/src/ModuleGraph/output/util.js

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @flow
+ */
+'use strict';
+
+import type {IdForPathFn, Module} from '../types.flow';
+
+// Transformed modules have the form
+//   __d(function(require, module, global, exports, dependencyMap) {
+//       /* code */
+//   });
+//
+// This function adds the numeric module ID, and an array with dependencies of
+// the dependencies of the module before the closing parenthesis.
+exports.addModuleIdsToModuleWrapper = (
+  module: Module,
+  idForPath: {path: string} => number,
+): string => {
+  const {dependencies, file} = module;
+  const {code} = file;
+  const index = code.lastIndexOf(')');
+
+  // calling `idForPath` on the module itself first gives us a lower module id
+  // for the file itself than for its dependencies. That reflects their order
+  // in the bundle.
+  const fileId = idForPath(file);
+
+  // This code runs for both development and production builds, after
+  // minification. That's why we leave out all spaces.
+  const depencyIds =
+    dependencies.length ? `,[${dependencies.map(idForPath).join(',')}]` : '';
+  return (
+    code.slice(0, index) +
+    `,${fileId}` +
+    depencyIds +
+    code.slice(index)
+  );
+};
+
+// Creates an idempotent function that returns numeric IDs for objects based
+// on their `path` property.
+exports.createIdForPathFn = (): ({path: string} => number) => {
+  const seen = new Map();
+  let next = 0;
+  return ({path}) => {
+    let id = seen.get(path);
+    if (id == null) {
+      id = next++;
+      seen.set(path, id);
+    }
+    return id;
+  };
+};
+
+// creates a series of virtual modules with require calls to the passed-in
+// modules.
+exports.requireCallsTo = function* (
+  modules: Iterable<Module>,
+  idForPath: IdForPathFn,
+): Iterable<Module> {
+  for (const module of modules) {
+    yield virtualModule(`require(${idForPath(module.file)});`);
+  }
+};
+
+// creates a virtual module (i.e. not corresponding to a file on disk)
+// with the given source code.
+exports.virtualModule = virtualModule;
+function virtualModule(code: string) {
+  return {
+    dependencies: [],
+    file: {
+      code,
+      path: '',
+      type: 'script',
+    }
+  };
+}