relay-compiler 1.3.0 → 1.5.0

package/lib/SkipRedundantNodesTransform.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-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.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule SkipRedundantNodesTransform
  * 
@@ -92,7 +90,7 @@ var IMap = require('immutable').Map;
  *       cc
  *     }
  *   }
-*  }
+ *  }
  * ```
  *
  * Becomes
@@ -107,7 +105,7 @@ var IMap = require('immutable').Map;
  *       cc
  *     }
  *   }
-*  }
+ *  }
  * ```
  *
  * 1 can be skipped because it is already fetched at the outer level.
@@ -120,16 +118,15 @@ var IMap = require('immutable').Map;
  * or nested maps for items with subselections (linked fields, inline fragments,
  * etc).
  */
-function transform(context) {
-  return context.documents().reduce(function (ctx, node) {
-    var selectionMap = new IMap();
-    var transformed = transformNode(node, selectionMap);
-    if (transformed) {
-      return ctx.add(transformed.node);
-    } else {
-      return ctx;
-    }
-  }, new (require('./RelayCompilerContext'))(context.schema));
+function skipRedundantNodesTransform(context) {
+  return require('./GraphQLIRTransformer').transform(context, {
+    Root: visitNode,
+    Fragment: visitNode
+  });
+}
+
+function visitNode(node) {
+  return transformNode(node, new IMap()).node;
 }
 
 /**
@@ -148,9 +145,10 @@ function transform(context) {
 function transformNode(node, selectionMap) {
   var selections = [];
   sortSelections(node.selections).forEach(function (selection) {
-    var identifier = require('./getIdentifierForRelaySelection')(selection);
+    var identifier = require('./getIdentifierForSelection')(selection);
     switch (selection.kind) {
       case 'ScalarField':
+      case 'DeferrableFragmentSpread':
       case 'FragmentSpread':
         {
           if (!selectionMap.has(identifier)) {
@@ -162,7 +160,7 @@ function transformNode(node, selectionMap) {
       case 'LinkedField':
         {
           var transformed = transformNode(selection, selectionMap.get(identifier) || new IMap());
-          if (transformed) {
+          if (transformed.node) {
             selections.push(transformed.node);
             selectionMap = selectionMap.set(identifier, transformed.selectionMap);
           }
@@ -174,7 +172,7 @@ function transformNode(node, selectionMap) {
           // Fork the selection map to prevent conditional selections from
           // affecting the outer "guaranteed" selections.
           var _transformed = transformNode(selection, selectionMap.get(identifier) || selectionMap);
-          if (_transformed) {
+          if (_transformed.node) {
             selections.push(_transformed.node);
             selectionMap = selectionMap.set(identifier, _transformed.selectionMap);
           }
@@ -184,15 +182,8 @@ function transformNode(node, selectionMap) {
         require('fbjs/lib/invariant')(false, 'SkipRedundantNodesTransform: Unexpected node kind `%s`.', selection.kind);
     }
   });
-  if (!selections.length) {
-    return null;
-  }
-  return {
-    selectionMap: selectionMap,
-    node: (0, _extends3['default'])({}, node, {
-      selections: selections
-    })
-  };
+  var nextNode = selections.length ? (0, _extends3['default'])({}, node, { selections: selections }) : null;
+  return { selectionMap: selectionMap, node: nextNode };
 }
 
 /**
@@ -204,4 +195,6 @@ function sortSelections(selections) {
   });
 }
 
-module.exports = { transform: transform };
+module.exports = {
+  transform: skipRedundantNodesTransform
+};

package/lib/SkipUnreachableNodeTransform.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-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.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule SkipUnreachableNodeTransform
  * 
@@ -30,18 +28,18 @@ var VARIABLE = 'variable';
  * - Any node with `@skip(if: true)`
  * - Any node with empty `selections`
  */
-function transform(context) {
-  var documents = context.documents();
+function skipUnreachableNodeTransform(context) {
   var fragments = new Map();
-  var nextContext = documents.reduce(function (ctx, node) {
-    if (node.kind === 'Root') {
-      var transformedNode = transformNode(context, fragments, node);
-      if (transformedNode) {
-        return ctx.add(transformedNode);
-      }
+  var nextContext = require('./GraphQLIRTransformer').transform(context, {
+    Root: function Root(node) {
+      return transformNode(context, fragments, node);
+    },
+    // Fragments are included below where referenced.
+    // Unreferenced fragments are not included.
+    Fragment: function Fragment(id) {
+      return null;
     }
-    return ctx;
-  }, new (require('./RelayCompilerContext'))(context.schema));
+  });
   return Array.from(fragments.values()).reduce(function (ctx, fragment) {
     return fragment ? ctx.add(fragment) : ctx;
   }, nextContext);
@@ -53,29 +51,50 @@ function transformNode(context, fragments, node) {
   while (queue.length) {
     var selection = queue.shift();
     var nextSelection = void 0;
-    if (selection.kind === 'Condition') {
-      var match = testCondition(selection);
-      if (match === PASS) {
-        queue.unshift.apply(queue, (0, _toConsumableArray3['default'])(selection.selections));
-      } else if (match === VARIABLE) {
+    switch (selection.kind) {
+      case 'Condition':
+        var match = testCondition(selection);
+        if (match === PASS) {
+          queue.unshift.apply(queue, (0, _toConsumableArray3['default'])(selection.selections));
+        } else if (match === VARIABLE) {
+          nextSelection = transformNode(context, fragments, selection);
+        }
+        break;
+      case 'DeferrableFragmentSpread':
+        // Skip deferred fragment spreads if the referenced fragment is empty
+        if (!fragments.has(selection.name)) {
+          var fragment = context.getFragment(selection.name);
+          var nextFragment = transformNode(context, fragments, fragment);
+          fragments.set(selection.name, nextFragment);
+        }
+        if (fragments.get(selection.name)) {
+          nextSelection = selection;
+        }
+        break;
+      case 'FragmentSpread':
+        // Skip fragment spreads if the referenced fragment is empty
+        if (!fragments.has(selection.name)) {
+          var _fragment = context.getFragment(selection.name);
+          var _nextFragment = transformNode(context, fragments, _fragment);
+          fragments.set(selection.name, _nextFragment);
+        }
+        if (fragments.get(selection.name)) {
+          nextSelection = selection;
+        }
+        break;
+      case 'LinkedField':
         nextSelection = transformNode(context, fragments, selection);
-      }
-    } else if (selection.kind === 'FragmentSpread') {
-      // Skip fragment spreads if the referenced fragment is empty
-      if (!fragments.has(selection.name)) {
-        var fragment = context.get(selection.name);
-        require('fbjs/lib/invariant')(fragment && fragment.kind === 'Fragment', 'SkipUnreachableNodeTransform: Found a reference to undefined ' + 'fragment `%s`.', selection.name);
-        var nextFragment = transformNode(context, fragments, fragment);
-        fragments.set(selection.name, nextFragment);
-      }
-      if (fragments.get(selection.name)) {
+        break;
+      case 'InlineFragment':
+        // TODO combine with the LinkedField case when flow supports this
+        nextSelection = transformNode(context, fragments, selection);
+        break;
+      case 'ScalarField':
         nextSelection = selection;
-      }
-    } else if (selection.kind === 'LinkedField' || selection.kind === 'InlineFragment') {
-      nextSelection = transformNode(context, fragments, selection);
-    } else {
-      // scalar field
-      nextSelection = selection;
+        break;
+      default:
+        selection.kind;
+        require('fbjs/lib/invariant')(false, 'SkipUnreachableNodeTransform: Unexpected selection kind `%s`.', selection.kind);
     }
     if (nextSelection) {
       selections = selections || [];
@@ -101,4 +120,6 @@ function testCondition(condition) {
   return condition.condition.value === condition.passingValue ? PASS : FAIL;
 }
 
-module.exports = { transform: transform };
+module.exports = {
+  transform: skipUnreachableNodeTransform
+};

package/lib/SourceControl.js

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
+
+var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
+
+var _toConsumableArray3 = _interopRequireDefault(require('babel-runtime/helpers/toConsumableArray'));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function execFile(cmd, args) {
+  return new Promise(function (resolve, reject) {
+    require('child_process').execFile(cmd, args, function (err) {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+/**
+ * An abstraction over the source control system to make it injectable.
+ */
+
+
+var SourceControlMercurial = {
+  addRemove: (() => {
+    var _ref = (0, _asyncToGenerator3.default)(function* (added, removed) {
+      // NOTE: Not using `hg addremove` as that has a bug when deleting a file
+      // that was just added, but not yet committed: T10711513
+      if (added.length > 0) {
+        yield execFile('hg', ['add'].concat((0, _toConsumableArray3['default'])(added)));
+      }
+      if (removed.length > 0) {
+        yield execFile('hg', ['forget'].concat((0, _toConsumableArray3['default'])(removed)));
+      }
+    });
+
+    function addRemove(_x, _x2) {
+      return _ref.apply(this, arguments);
+    }
+
+    return addRemove;
+  })()
+};
+
+module.exports = {
+  SourceControlMercurial: SourceControlMercurial
+};

package/lib/StripUnusedVariablesTransform.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-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.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule StripUnusedVariablesTransform
  * 
@@ -21,49 +19,96 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'd
  * A transform that removes variables from root queries that aren't referenced
  * by the query itself.
  */
-function transform(context) {
-  return context.documents().reduce(function (ctx, node) {
-    return ctx.add(node.kind === 'Root' ? transformRoot(context, node) : node);
-  }, new (require('./RelayCompilerContext'))(context.schema));
-}
-
-function transformRoot(context, root) {
-  var state = {
-    referencedVariables: new Set()
-  };
-  var newContext = require('./RelayIRTransformer').transform(require('./filterContextForNode')(root, context), {
-    Argument: visitArgument,
-    Condition: visitCondition
-  }, function () {
-    return state;
+function stripUnusedVariablesTransform(context) {
+  var fragmentToVariables = new Map();
+  var fragmentToFragmentSpreads = new Map();
+  var rootToVariables = new Map();
+  var rootToFragmentSpreads = new Map();
+  context.forEachDocument(function (document) {
+    var fragmentVariables = void 0;
+    var fragmentFragmentSpreads = void 0;
+    var rootVariables = void 0;
+    var rootFragmentSpreads = void 0;
+    require('./GraphQLIRVisitor').visit(document, {
+      Root: {
+        enter: function enter(root) {
+          rootVariables = new Set();
+          rootToVariables.set(root.name, rootVariables);
+          rootFragmentSpreads = new Set();
+          rootToFragmentSpreads.set(root.name, rootFragmentSpreads);
+        },
+        leave: function leave(root) {
+          rootVariables = null;
+          rootFragmentSpreads = null;
+        }
+      },
+      Fragment: {
+        enter: function enter(fragment) {
+          fragmentVariables = new Set();
+          fragmentToVariables.set(fragment.name, fragmentVariables);
+          fragmentFragmentSpreads = new Set();
+          fragmentToFragmentSpreads.set(fragment.name, fragmentFragmentSpreads);
+        },
+        leave: function leave(fragment) {
+          fragmentVariables = null;
+          fragmentFragmentSpreads = null;
+        }
+      },
+      Variable: function Variable(variable) {
+        fragmentVariables && fragmentVariables.add(variable.variableName);
+        rootVariables && rootVariables.add(variable.variableName);
+      },
+      FragmentSpread: function FragmentSpread(spread) {
+        fragmentFragmentSpreads && fragmentFragmentSpreads.add(spread.name);
+        rootFragmentSpreads && rootFragmentSpreads.add(spread.name);
+      }
+    });
   });
-  var transformedNode = newContext.getRoot(root.name);
-  /**
-   * Remove the extraneous arguments *after* transform returns, since fragments
-   * could be transformed after the root query.
-   */
-  return (0, _extends3['default'])({}, transformedNode, {
-    argumentDefinitions: transformedNode.argumentDefinitions.filter(function (arg) {
-      return state.referencedVariables.has(arg.name);
-    })
+  var variablesMemo = new Map();
+  rootToVariables.forEach(function (variables, root) {
+    Array.from(require('./nullthrowsOSS')(rootToFragmentSpreads.get(root), 'root ' + root + ' wasn\'t found in StripUnusedVariablesTransform')).forEach(function (spread) {
+      return into(variables, allVariablesReferencedInFragment(variablesMemo, spread, fragmentToVariables, fragmentToFragmentSpreads));
+    });
+  });
+  return require('./GraphQLIRTransformer').transform(context, {
+    Root: function Root(root) {
+      return transformRoot(context, root, require('./nullthrowsOSS')(rootToVariables.get(root.name), 'root ' + root.name + ' wasn\'t found in StripUnusedVariablesTransform'));
+    },
+    // Include fragments, but do not traverse into them.
+    Fragment: function Fragment(id) {
+      return id;
+    }
   });
 }
 
-function visitArgument(argument, state) {
-  var value = argument.value;
-
-  if (value.kind === 'Variable') {
-    state.referencedVariables.add(value.variableName);
+function allVariablesReferencedInFragment(variablesMemo, fragment, fragmentToVariables, fragmentToFragmentSpreads) {
+  var variables = variablesMemo.get(fragment);
+  if (!variables) {
+    var directVariables = require('./nullthrowsOSS')(fragmentToVariables.get(fragment), 'fragment ' + fragment + ' wasn\'t found in StripUnusedVariablesTransform');
+    variables = Array.from(require('./nullthrowsOSS')(fragmentToFragmentSpreads.get(fragment), 'fragment ' + fragment + ' wasn\'t found in StripUnusedVariablesTransform')).reduce(function (allVariables, fragmentSpread) {
+      return into(allVariables, allVariablesReferencedInFragment(variablesMemo, fragmentSpread, fragmentToVariables, fragmentToFragmentSpreads));
+    }, directVariables);
+    variablesMemo.set(fragment, variables);
   }
-  return argument;
+  return variables;
 }
 
-function visitCondition(condition, state) {
-  var innerCondition = condition.condition;
-  if (innerCondition.kind === 'Variable') {
-    state.referencedVariables.add(innerCondition.variableName);
-  }
-  return condition;
+function transformRoot(context, root, variables) {
+  return (0, _extends3['default'])({}, root, {
+    argumentDefinitions: root.argumentDefinitions.filter(function (arg) {
+      return variables.has(arg.name);
+    })
+  });
+}
+
+// Returns the union of setA and setB. Modifies setA!
+function into(setA, setB) {
+  setB.forEach(function (item) {
+    return setA.add(item);
+  });
+  return setA;
 }
 
-module.exports = { transform: transform };
+module.exports = {
+  transform: stripUnusedVariablesTransform
+};

package/lib/areEqualOSS.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-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.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * @providesModule areEqualOSS
  * 

package/lib/compileRelayArtifacts.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _toConsumableArray3 = _interopRequireDefault(require('babel-runtime/helpers/toConsumableArray'));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var _require = require('./GraphQLCompilerPublic'),
+    Profiler = _require.Profiler;
+
+// TODO T21875029 relay-runtime
+
+
+/**
+ * Transforms the provided compiler context
+ *
+ * compileRelayArtifacts generates artifacts for Relay's runtime as a result of
+ * applying a series of transforms. Each kind of artifact is dependent on
+ * transforms being applied in the following order:
+ *
+ *   - Fragment Readers: commonTransforms, fragmentTransforms
+ *   - Operation Writers: commonTransforms, queryTransforms, codegenTransforms
+ *   - GraphQL Text: commonTransforms, queryTransforms, printTransforms
+ *
+ * The order of the transforms applied for each artifact below is important.
+ * CompilerContext will memoize applying each transform, so while
+ * `commonTransforms` appears in each artifacts' application, it will not result
+ * in repeated work as long as the order remains consistent across each context.
+ */
+function compileRelayArtifacts(context, transforms, reporter) {
+  return Profiler.run('GraphQLCompiler.compile', function () {
+    // The fragment is used for reading data from the normalized store.
+    var fragmentContext = context.applyTransforms([].concat((0, _toConsumableArray3['default'])(transforms.commonTransforms), (0, _toConsumableArray3['default'])(transforms.fragmentTransforms)), reporter);
+
+    // The unflattened query is used for printing, since flattening creates an
+    // invalid query.
+    var printContext = context.applyTransforms([].concat((0, _toConsumableArray3['default'])(transforms.commonTransforms), (0, _toConsumableArray3['default'])(transforms.queryTransforms), (0, _toConsumableArray3['default'])(transforms.printTransforms)), reporter);
+
+    // The flattened query is used for codegen in order to reduce the number of
+    // duplicate fields that must be processed during response normalization.
+    var codeGenContext = context.applyTransforms([].concat((0, _toConsumableArray3['default'])(transforms.commonTransforms), (0, _toConsumableArray3['default'])(transforms.queryTransforms), (0, _toConsumableArray3['default'])(transforms.codegenTransforms)), reporter);
+
+    return fragmentContext.documents().map(function (node) {
+      return require('./RelayCodeGenerator').generate(node.kind === 'Fragment' ? node : {
+        kind: 'Batch',
+        metadata: codeGenContext.getRoot(node.name).metadata || {},
+        name: node.name,
+        fragment: {
+          kind: 'Fragment',
+          argumentDefinitions: node.argumentDefinitions,
+          directives: node.directives,
+          metadata: null,
+          name: node.name,
+          selections: node.selections,
+          type: node.type
+        },
+        requests: require('./requestsForOperation')(printContext, codeGenContext, node.name)
+      });
+    });
+  });
+}
+
+module.exports = compileRelayArtifacts;

package/lib/dedent.js

@@ -1,12 +1,9 @@
 /**
  * Copyright (c) 2013-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.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
- * @providesModule dedent
  * 
  * @format
  */

package/lib/dedupeJSONStringify.js

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule dedupeJSONStringify
+ * 
+ * @format
+ */
+
+'use strict';
+
+/**
+ * This function works similar to JSON.stringify except that for the case there
+ * are multiple common subtrees, it generates a string for a IIFE that re-uses
+ * the same objects for the duplicate subtrees.
+ */
+
+function dedupeJSONStringify(jsonValue) {
+  var metadataForHash = new Map();
+  var metadataForVal = new WeakMap();
+  var varDefs = [];
+  collectMetadata(jsonValue);
+  collectDuplicates(jsonValue);
+  var code = printJSCode(false, '', jsonValue);
+  return varDefs.length === 0 ? code : '(function(){\nvar ' + varDefs.join(',\n') + ';\nreturn ' + code + ';\n})()';
+
+  // Collect common metadata for each object in the value tree, ensuring that
+  // equivalent values have the *same reference* to the same metadata. Note that
+  // the hashes generated are not exactly JSON, but still identify equivalent
+  // values. Runs in linear time due to hashing in a bottom-up recursion.
+  function collectMetadata(value) {
+    if (value == null || typeof value !== 'object') {
+      return JSON.stringify(value);
+    }
+    var hash = void 0;
+    if (Array.isArray(value)) {
+      hash = '[';
+      for (var i = 0; i < value.length; i++) {
+        hash += collectMetadata(value[i]) + ',';
+      }
+    } else {
+      hash = '{';
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          hash += k + ':' + collectMetadata(value[k]) + ',';
+        }
+      }
+    }
+    var metadata = metadataForHash.get(hash);
+    if (!metadata) {
+      metadata = { value: value, hash: hash, isDuplicate: false };
+      metadataForHash.set(hash, metadata);
+    }
+    metadataForVal.set(value, metadata);
+    return hash;
+  }
+
+  // Using top-down recursion, linearly scan the JSON tree to determine which
+  // values should be deduplicated.
+  function collectDuplicates(value) {
+    if (value == null || typeof value !== 'object') {
+      return;
+    }
+    var metadata = metadataForVal.get(value);
+    // Only consider duplicates with hashes longer than 2 (excludes [] and {}).
+    if (metadata && metadata.value !== value && metadata.hash.length > 2) {
+      metadata.isDuplicate = true;
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (var i = 0; i < value.length; i++) {
+        collectDuplicates(value[i]);
+      }
+    } else {
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          collectDuplicates(value[k]);
+        }
+      }
+    }
+  }
+
+  // Stringify JS, replacing duplicates with variable references.
+  function printJSCode(isDupedVar, depth, value) {
+    if (value == null || typeof value !== 'object') {
+      return JSON.stringify(value);
+    }
+    // Only use variable references at depth beyond the top level.
+    if (depth !== '') {
+      var metadata = metadataForVal.get(value);
+      if (metadata && metadata.isDuplicate) {
+        if (!metadata.varName) {
+          var refCode = printJSCode(true, '', value);
+          metadata.varName = 'v' + varDefs.length;
+          varDefs.push(metadata.varName + ' = ' + refCode);
+        }
+        return metadata.varName;
+      }
+    }
+    var str = void 0;
+    var isEmpty = true;
+    var depth2 = depth + '  ';
+    if (Array.isArray(value)) {
+      // Empty arrays can only have one inferred flow type and then conflict if
+      // used in different places, this is unsound if we would write to them but
+      // this whole module is based on the idea of a read only JSON tree.
+      if (isDupedVar && value.length === 0) {
+        return '([]/*: any*/)';
+      }
+      str = '[';
+      for (var i = 0; i < value.length; i++) {
+        str += (isEmpty ? '\n' : ',\n') + depth2 + printJSCode(isDupedVar, depth2, value[i]);
+        isEmpty = false;
+      }
+      str += isEmpty ? ']' : '\n' + depth + ']';
+    } else {
+      str = '{';
+      for (var k in value) {
+        if (value.hasOwnProperty(k) && value[k] !== undefined) {
+          str += (isEmpty ? '\n' : ',\n') + depth2 + JSON.stringify(k) + ': ' + printJSCode(isDupedVar, depth2, value[k]);
+          isEmpty = false;
+        }
+      }
+      str += isEmpty ? '}' : '\n' + depth + '}';
+    }
+    return str;
+  }
+}
+
+module.exports = dedupeJSONStringify;