TypeScript acorn-walk.findNodeAt函数代码示例

    public async setNetworks(network: INetwork): Promise<void> {
      const ast = await this.getAST();
      const moduleExports: IFound = walk.findNodeAt(ast as ESTree.Node, null, null, isModuleExportsExpression);

      if (moduleExports.node) {
        const node = moduleExports.node as ESTree.ExpressionStatement;
        const rightExpression = (node.expression as ESTree.AssignmentExpression).right;

        if (rightExpression.type === 'ObjectExpression') {
          let networksNode = findProperty(rightExpression, 'networks');
          if (!networksNode) {
            networksNode = generateProperty('networks', generateObjectExpression());
            rightExpression.properties.push(networksNode);
          }

          if (networksNode.value.type === 'ObjectExpression') {
            const isExist = findProperty(networksNode.value, network.name);
            if (isExist) {
              throw Error(`Network with name ${network.name} already existed in truffle-config.js`);
            } else {
              const networkNode = generateProperty(network.name, generateObjectExpression());
              networkNode.value = networkOptionsToAst(network);
              networksNode.value.properties.push(networkNode);
            }
          }
        }
      }

      this.ast = ast;
      return this.writeAST();
    }

    public async getNetworks(): Promise<INetwork[]> {
      const ast = await this.getAST();
      const networks: INetwork[] = [];
      const moduleExports: IFound = walk.findNodeAt(ast as ESTree.Node, null, null, isModuleExportsExpression);

      if (moduleExports.node) {
        const node = moduleExports.node as ESTree.ExpressionStatement;
        const rightExpression = (node.expression as ESTree.AssignmentExpression).right;

        if (rightExpression.type === 'ObjectExpression') {
          const networksNode = findProperty(rightExpression, 'networks');
          if (networksNode && networksNode.value.type === 'ObjectExpression') {
            networksNode.value.properties.forEach((property: ESTree.Property) => {
              if (property.key.type === 'Identifier') {
                networks.push({
                  name: property.key.name,
                  options: astToNetworkOptions(property.value as ESTree.ObjectExpression),
                });
              }
              if (property.key.type === 'Literal') {
                networks.push({
                  name: '' + property.key.value,
                  options: astToNetworkOptions(property.value as ESTree.ObjectExpression),
                });
              }
            });
          }
        }
      }

      return networks;
    }

    public async importFs(): Promise<void> {
      const ast = await this.getAST();
      const fsRequired: IFound = walk.findNodeAt(ast as ESTree.Node, null, null, isVarDeclaration('fs'));
      if (!fsRequired) {
        const declaration = generateVariableDeclaration('fs', 'require', 'fs');
        (ast as ESTree.Program).body.unshift(declaration);
      }

      this.ast = ast;
      await this.writeAST();
    }

  function astToNetworkOptions(node: ESTree.ObjectExpression): INetworkOption {
    const options: INetworkOption = {
      network_id: '*',
    };

    const id = findProperty(node, 'network_id');
    if (id && id.value.type === 'Literal' &&
       (typeof id.value.value === 'string' || typeof id.value.value === 'number')) {
      options.network_id = id.value.value;
    }

    const port = findProperty(node, 'port');
    if (port && port.value.type === 'Literal' && typeof port.value.value === 'number') {
      options.port = port.value.value;
    }

    const host = findProperty(node, 'host');
    if (host && host.value.type === 'Literal' && typeof host.value.value === 'string') {
      options.host = host.value.value;
    }

    const websockets = findProperty(node, 'websockets');
    if (websockets && websockets.value.type === 'Literal' && typeof websockets.value.value === 'boolean') {
      options.websockets = websockets.value.value;
    }

    const gas = findProperty(node, 'gas');
    if (gas && gas.value.type === 'Literal' && typeof gas.value.value === 'number') {
      options.gas = gas.value.value;
    }

    const gasPrice = findProperty(node, 'gasPrice');
    if (gasPrice && gasPrice.value.type === 'Literal' && typeof gasPrice.value.value === 'number') {
      options.gasPrice = gasPrice.value.value;
    }

    const from = findProperty(node, 'from');
    if (from && from.value.type === 'Literal' && typeof from.value.value === 'string') {
      options.from = from.value.value;
    }

    const skipDryRun = findProperty(node, 'skipDryRun');
    if (skipDryRun && skipDryRun.value.type === 'Literal' && typeof skipDryRun.value.value === 'boolean') {
      options.skipDryRun = skipDryRun.value.value;
    }

    const timeoutBlocks = findProperty(node, 'timeoutBlocks');
    if (timeoutBlocks && timeoutBlocks.value.type === 'Literal' && typeof timeoutBlocks.value.value === 'number') {
      options.timeoutBlocks = timeoutBlocks.value.value;
    }

    const provider = findProperty(node, 'provider');
    if (provider && provider.value.type === 'FunctionExpression') {
      const hdWalletProvider: IFound = walk.findNodeAt(provider, null, null, isHDWalletProvider);
      if (hdWalletProvider.node && hdWalletProvider.node.type === 'NewExpression') {
        options.provider = astToHDWalletProvider(hdWalletProvider.node);
      }
    }

    if (provider && provider.value.type === 'NewExpression') {
      options.provider = astToHDWalletProvider(provider.value);
    }

    const consortiumId = findProperty(node, 'consortium_id');
    if (consortiumId && consortiumId.value.type === 'Literal' && typeof consortiumId.value.value === 'number') {
      options.consortium_id = consortiumId.value.value;
    }

    return options;
  }