How to use json-stable-stringify - 10 common examples

let batchPromises = _.map(results, (result) => {
    let savePath = `${distPath}${result.id}.json`;
    let stringContent = stringify(result, {space: '  '});

    return (callback) => {
      // Force JSON to order keys, so diffs are easier to read
      fs.writeFile(savePath, stringContent, () => {
        callback(null, result);
      });
    };
  });

private setup() {
    let syntax = loadGlimmerSyntax(this.params.compilerPath);
    initializeEmberENV(syntax, this.params.EmberENV);
    let cacheKey = createHash('md5')
      .update(
        stringify({
          // todo: get resolver reflected in cacheKey
          syntax: syntax.cacheKey,
        })
      )
      .digest('hex');
    return { syntax, cacheKey };
  }

function main() {
  const args = parseArgs();
  const result = loadRepository(args.repositoryPath, args.rootRef);
  console.log(stringify(result, {space: 4}));
}

    createMapStream(record => stringify(record, { space: '  ' })),
    createIntersperseStream(RECORD_SEPARATOR),

columns: logColumns.map(logColumn => {
    if (SavedSourceConfigurationTimestampColumnRuntimeType.is(logColumn)) {
      return {
        timestamp: document.key.time,
      };
    } else if (SavedSourceConfigurationMessageColumnRuntimeType.is(logColumn)) {
      return {
        message: formatLogMessage(document.fields),
      };
    } else {
      return {
        field: logColumn.fieldColumn.field,
        value: stringify(document.fields[logColumn.fieldColumn.field] || null),
      };
    }
  }),
});

arr.forEach((s: string) => {
    if (s == null) {
      throw new Error(`${what}: ${String(s)} in ${stringify(arr)}`);
    }
    if (s.indexOf(SEPARATOR) !== -1) {
      throw new Error(`${what}: NUL char: ${stringify(arr)}`);
    }
  });
}

mergeCommitHash(): ?string {
    const mergeEdge = this.neighbors({
      edgeType: MERGED_AS_EDGE_TYPE,
      nodeType: COMMIT_NODE_TYPE,
      direction: "OUT",
    }).map(({edge}) => edge);
    if (mergeEdge.length > 1) {
      throw new Error(
        `Node at ${stringify(this.address())} has too many MERGED_AS edges`
      );
    }
    if (mergeEdge.length === 0) {
      return null;
    }
    const payload: MergedAsEdgePayload = (mergeEdge[0].payload: any);
    return payload.hash;
  }

} else if (webhook === Object(webhook)) {
    webhooks.push(webhook);
  } else {
    throw new Error('fields missing: second argument(webhook) is necessary');
  }

  const populateBody = () => {
    bodyCopy = {};
    bodyCopy.webhooks = webhooks;
    bodyCopy.query = query;
    bodyCopy.type = type;
  };

  populateBody();

  const encode64 = btoa(stringify(query));
  const path = `.percolator/webhooks-0-${typeString}-0-${encode64}`;

  this.change = () => {
    webhooks = [];

    if (typeof parsedArgs === 'string') {
      const webhook2 = {};
      webhook2.url = parsedArgs;
      webhook2.method = 'POST';
      webhooks.push(webhook2);
    } else if (parsedArgs.constructor === Array) {
      webhooks = parsedArgs;
    } else if (parsedArgs === Object(parsedArgs)) {
      webhooks.push(parsedArgs);
    } else {
      throw new Error('fields missing: one of webhook or url fields is required');

function assertExists(item: ?T, address: N.StructuredAddress): T {
  if (item == null) {
    throw new Error(
      `Invariant violation: Expected entity for ${stringify(address)}`
    );
  }
  return item;
}

export function writeRegistry(
  registry: RepoIdRegistry,
  sourcecredDirectory: string
) {
  const registryFile = path.join(sourcecredDirectory, REPO_ID_REGISTRY_FILE);
  fs.writeFileSync(registryFile, stringify(toJSON(registry)));
}