text: const _ = require("lodash")
  const BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPlugin
  const path = require("path")
  const Promise = require("bluebird")
  
  const { createFilePath } = require("gatsby-source-filesystem")
  
  exports.onCreateNode = ({ node, getNode, actions }) => {
    const { createNodeField } = actions
    if (node.internal.type === "MarkdownRemark") {
      const slug = createFilePath({ node, getNode })
      const fileNode = getNode(node.parent)
      const source = fileNode.sourceInstanceName
      const separtorIndex = ~slug.indexOf("--") ? slug.indexOf("--") : 0
      const shortSlugStart = separtorIndex ? separtorIndex + 2 : 0
  
      if (source !== "parts") {
        createNodeField({
          node,
          name: "slug",
          value: `${separtorIndex ? "/" : ""}${slug.substring(shortSlugStart)}`
        })
      }
      createNodeField({
        node,
        name: "prefix",
        value: separtorIndex ? slug.substring(1, separtorIndex) : ""
      })
      createNodeField({
        node,
        name: "source",
        value: source
      })
    }
  }
  
  exports.createPages = ({ graphql, actions }) => {
    const { createPage } = actions
  
    return new Promise((resolve, reject) => {
      const postTemplate = path.resolve("./src/templates/PostTemplate.js")
      const pageTemplate = path.resolve("./src/templates/PageTemplate.js")
      const tagTemplate = path.resolve("./src/templates/TagTemplate.js")
      const categoryTemplate = path.resolve("./src/templates/CategoryTemplate.js")
  
      // Do not create draft post files in production.
      const activeEnv = process.env.ACTIVE_ENV || process.env.NODE_ENV || "development"
      let filters = "filter: { fields: { slug: { ne: null } } }"
      if (activeEnv == "production") filters = "filter: { fields: { slug: { ne: null } , prefix: { ne: null } } }"
  
      resolve(
        graphql(`
          {
            postsRemark: allMarkdownRemark(
              ` + filters + `
              sort: { fields: [fields___prefix], order: DESC }
              limit: 1000
            ) {
              edges {
                node {
                  id
                  fields {
                    slug
                    prefix
                    source
                  }
                  frontmatter {
                    title
                    category
                  }
                }
              }
            }
            tagsGroup: allMarkdownRemark(limit: 2000) {
              group(field: frontmatter___tags) {
                fieldValue
              }
            }
          }
        `).then(result => {
          if (result.errors) {
            console.log(result.errors)
            reject(result.errors)
          }
  
          const items = result.data.postsRemark.edges
  
          // Create category list
          const categorySet = new Set()
          items.forEach(edge => {
            const {
              node: {
                frontmatter: { category }
              }
            } = edge
  
            if (category && category !== null) {
              categorySet.add(category)
            }
          })
  
          // Create category pages
          const categoryList = Array.from(categorySet)
          categoryList.forEach(category => {
            createPage({
              path: `/category/${_.kebabCase(category)}/`,
              component: categoryTemplate,
              context: {
                category
              }
            })
          })
  
          // Create posts
          const posts = items.filter(item => item.node.fields.source === "posts")
          posts.forEach(({ node }, index) => {
            const slug = node.fields.slug
            const next = index === 0 ? undefined : posts[index - 1].node
            const prev = index === posts.length - 1 ? undefined : posts[index + 1].node
            const source = node.fields.source
  
            createPage({
              path: slug,
              component: postTemplate,
              context: {
                slug,
                prev,
                next,
                source
              }
            })
          })
  
          // and pages.
          const pages = items.filter(item => item.node.fields.source === "pages")
          pages.forEach(({ node }) => {
            const slug = node.fields.slug
            const source = node.fields.source
  
            createPage({
              path: slug,
              component: pageTemplate,
              context: {
                slug,
                source
              }
            })
          })
  
          // tag data
          const tags = result.data.tagsGroup.group
  
          // Create tag pages
          tags.forEach(tag => {
            createPage({
              path: `/tag/${_.kebabCase(tag.fieldValue)}/`,
              component: tagTemplate,
              context: {
                tag: tag.fieldValue
              }
            })
          })
        })
      )
    })
  }
  
  exports.onCreateWebpackConfig = ({ stage, actions }, options) => {
    switch (stage) {
    case "build-javascript":
      actions.setWebpackConfig({
        resolve: {
          alias: {
            "@": path.resolve("src"),
            "@cmp": path.resolve("src", "components")
          }
        },
        plugins: [
          new BundleAnalyzerPlugin({
            analyzerMode: "static",
            reportFilename: "./report/treemap.html",
            openAnalyzer: true,
            logLevel: "error",
            defaultSizes: "gzip"
          })
        ]
      })
  
      break
    default:
      actions.setWebpackConfig({
        resolve: {
          alias: {
            "@": path.resolve("src"),
            "@cmp": path.resolve("src", "components")
          }
        }
      })
    }
  }
  