Function package

packages/dev/parcel-packager-docs/DocsPackager.js:24–243

({bundle, bundleGraph, options})

    nodes = {};
  },
  async package({bundle, bundleGraph, options}) {
    let promises = [];
    bundle.traverseAssets(asset => {
      promises.push(parse(asset));
    });

    let code = new Map(await Promise.all(promises));
    try {
      var result = processAsset(bundle.getEntryAssets()[0]);
    } catch (err) {
      console.log(err.stack);
    }

    function processAsset(asset) {
      if (cache.has(asset.id)) {
        return cache.get(asset.id);
      }

      let res = {};
      cache.set(asset.id, res);
      _processAsset(asset, res);
      return res;
    }

    function _processAsset(asset, res) {
      let obj = processCode(asset, code.get(asset.id));
      for (let [exported] of asset.symbols) {
        let {asset: resolvedAsset, exportSymbol} = bundleGraph.getSymbolResolution(asset, exported);
        let processed = resolvedAsset.id === asset.id ? obj : processAsset(resolvedAsset);

        if (exportSymbol === '*') {
          Object.assign(res, processed);
        } else {
          // Re-exported with different name (e.g. export {useGridCell as useTableCell})
          if (exportSymbol !== exported) {
            let clone = {...processed[exportSymbol]};
            clone.name = exported;
            res[exported] = clone;
          } else {
            res[exported] = processed[exportSymbol];
          }
        }
      }

      let deps = bundleGraph.getDependencies(asset);
      for (let dep of deps) {
        let wildcard = dep.symbols.get('*');
        if (wildcard && wildcard.local === '*') {
          let resolved = bundleGraph.getResolvedAsset(dep, bundle);
          Object.assign(res, processAsset(resolved));
        }
      }
    }

    function processCode(asset, obj) {
      let application;
      let paramStack = [];
      let keyStack = [];