TypeScript promises.writeFile方法代码示例

async function topic(options: Options) {
  if (!options.title) {
    console.error('No title given!')
    process.exit(1)
    return
  }

  const topics = path.resolve(__dirname, `../src/topics`)
  const slug = options.slug || makeSlug(options.title)

  const dir = path.join(topics, slug)

  try {
    await fs.promises.access(dir, fs.constants.F_OK)
    console.error(`The topic '${options.title}' already exists`)
    return
  } catch (error) {
    const mdx = `---\ntitle: ${options.title}\ndescription: This is a starter description\n${
      options.topic ? `\nparent: ${options.topic}\n` : ''
    }\ncover:\n  image: full.jpg\n  caption: Starter caption.\n---\n\nSome starter content`

    await fs.promises.mkdir(dir, { recursive: true })

    const file = `${dir}/index.mdx`
    await fs.promises.writeFile(file, mdx)

    console.log(`Created a new topic: ${file.replace(path.resolve(__dirname, '..'), '')}`)
  }
}

// Create a debugging version of our AutoRest abstraction (ideally we'd just
// launch AutoRest and parse the readme.md, but that's also nontrivial to get
// working correctly)
async function getDebugGeneratorContext(swaggerPath : string, outputPath?: string) : Promise<IGeneratorContext> {
    const dir = outputPath || path.dirname(swaggerPath);
    const settings : { [key: string]: any; } = {
        'input-file': swaggerPath,
        'output-folder': dir,
        'clear-output-folder': false,
        'azure-track2-csharp': true
    };
    const ctx = {
        async getSetting(key: string) : Promise<any> { return Promise.resolve(settings[key]); },
        async getInputUris() : Promise<string[]> { return Promise.resolve([swaggerPath]); },
        log(message: string): void { console.log(`INFORMATION: ${message}`); },
        warn(message: string): void { console.error(chalk.yellow(`WARNING: ${message}`)); },
        error(message: string): void { console.error(chalk.red(`ERROR: ${message}`)); },
        verbose(message: string): void { console.log(`VERBOSE: ${message}`); },
        async readFile(filename: string): Promise<string> {
            const data = await fs.promises.readFile(filename);
            return data.toString();
        },
        async writeFile(filename: string, content: string): Promise<void> {
            ctx.verbose(`Emitting file ${filename}`);
            filename = path.join(dir, filename);
            await fs.promises.mkdir(path.dirname(filename), { recursive: true });
            await fs.promises.writeFile(filename, content, 'utf8');
        }
    }
    return ctx;
}

async function note(options: Options) {
  if (!options.topic) {
    console.error('No topic given!')
    process.exit(1)
    return
  }

  if (!(await topicExists(options.topic))) {
    console.error(`The topic "${options.topic}" does not exists`)
    process.exit(1)
    return
  }

  const date = new Date()

  const publishedAt = date.toISOString()
  const text = '_Content goes here_'
  const mdx = `---\npublishedAt: ${publishedAt}\n---\n\n${text}\n`

  const dir = await uniqueNote(options.topic, date)
  await fs.promises.mkdir(dir, { recursive: true })

  const file = `${dir}/index.mdx`
  await fs.promises.writeFile(file, mdx)

  console.log(`New note created at: ${file.replace(path.resolve(__dirname, '..'), '')}`)
}

async function main() {
  const root = new Root();
  const { resolvePath } = root;
  const numDirectoriesToStrip = 2;
  let initialOrigin: string|null;
  root.resolvePath = (origin, target) => {
    if (!origin) {
      initialOrigin = target;
      for (let i = 0; i <= numDirectoriesToStrip; i++) {
        initialOrigin = path.dirname(initialOrigin);
      }
      return resolvePath(origin, target);
    }
    return path.resolve(initialOrigin!, target);
  };
  const traceProto = await root.load(process.argv[2]);
  const Trace = traceProto.lookupType("Trace");
  const payload = await fs.promises.readFile(process.argv[3]);
  const msg = Trace.decode(payload).toJSON();
  const output = {
    traceEvents: msg.packet
      .filter((packet: any) => !!packet.chromeEvents)
      .map((packet: any) => packet.chromeEvents.traceEvents)
      .map((traceEvents: any) => traceEvents.map((e: any) => {

        const bind_id = (e.flags & (TRACE_EVENT_FLAG_FLOW_IN |
          TRACE_EVENT_FLAG_FLOW_OUT)) ? e.bindId : undefined;
        const scope = (e.flags & TRACE_EVENT_FLAG_HAS_ID) && e.scope ?
            e.scope : undefined;

        return {
          pid: e.processId,
          tid: e.threadId,
          ts: parseIntOrThrow(e.timestamp),
          tts: parseIntOrThrow(e.threadTimestamp),
          ph: String.fromCodePoint(e.phase),
          cat: e.categoryGroupName,
          name: e.name,
          dur: parseIntOrThrow(e.duration),
          tdur: parseIntOrThrow(e.threadDuration),
          bind_id: bind_id,
          flow_in: e.flags & TRACE_EVENT_FLAG_FLOW_IN ? true : undefined,
          flow_out: e.flags & TRACE_EVENT_FLAG_FLOW_OUT ? true : undefined,
          scope: scope,
          id: (e.flags & TRACE_EVENT_FLAG_HAS_ID) ?
              uint64AsHexString(e.id) : undefined,
          args: (e.args || []).reduce((js_args: any, proto_arg: any) => {
            js_args[proto_arg.name] = parseArgValue(proto_arg);
            return js_args;
          }, {})
        };
      }))
      .reduce(flatten, [])
  };
  await fs.promises.writeFile(process.argv[4], JSON.stringify(output, null, 2));
}

export async function savePngDiff(file: string, png: PNG): Promise<string> {
    const data = PNG.sync.write(png);
    const outputDir = path.resolve(process.cwd(), './build/test-output/integration');
    const diffPath = path.resolve(outputDir, file);

    await fs.mkdir(outputDir, { recursive: true });
    await fs.writeFile(diffPath, data);

    return diffPath;
}

async function twitter(topic: string, pathname: string) {
  const [_null, username, _type, id] = pathname.split('/')

  const { data } = await axios.get('https://api.twitter.com/1.1/statuses/show.json', {
    headers: { Authorization: `Bearer ${process.env.TWITTER_BEARER_TOKEN}` },
    params: { id },
  })

  const date = dateFns.parse(data.created_at, 'eee MMM dd HH:mm:ss xxxx yyyy', new Date())

  const dir = await uniqueNote(topic, date)
  await fs.promises.mkdir(dir, { recursive: true })

  async function reducer(acc: Promise<string[]>, { media_url_https, type }: { media_url_https: string; type: string }) {
    if (type !== 'photo') return acc

    try {
      const basename = path.basename(media_url_https)
      const image = `${dir}/${basename}`
      const writer = fs.createWriteStream(image)
      const response = await axios.get(media_url_https, { responseType: 'stream' })

      await new Promise((resolve, reject) => {
        response.data.pipe(writer)
        writer.on('error', reject)
        writer.on('finish', resolve)
      })
      return [...(await acc), basename]
    } catch (e) {
      console.error(e)
      return acc
    }
  }

  if (data.entities && data.entities.media) {
    const images = await data.entities.media.reduce(reducer, Promise.resolve([]))
    console.log('Downloaded images attached to this tweet:', images)
  }

  const publishedAt = date.toISOString()
  const text = dePants(data.text)
  const url = `https://twitter.com${pathname}`
  const mdx = `---\npublishedAt: ${publishedAt}\n\ntwitter:\n  url: ${url}\n---\n\n${text}\n`

  const file = `${dir}/index.mdx`
  await fs.promises.writeFile(file, mdx)

  console.log(`Imported tweet to: ${file.replace(path.resolve(__dirname, '..'), '')}`)
}

async function fetchAndSave(
    cookieHeaders: string[],
    player1Username: string,
    player2Username: string,
    startGameIndex: number,
    numGames: number): Promise<void> {
  const response = await fetch(cookieHeaders, player1Username, player2Username, startGameIndex, numGames)
  player1Username = player1Username.length === 0 ? 'ALL' : player1Username
  player2Username = player2Username.length === 0 ? 'ALL' : player2Username
  const startNum = startGameIndex + 1;
  const endNum = startNum + numGames - 1
  const fileName = `pente_${player1Username}-${player2Username}-${startNum}-${endNum}.zip`
  console.log(`Downloaded games ${startNum} to ${endNum}`)
  return fs.promises.writeFile(fileName, response.data)
}

async function entry(options: Options) {
  if (!options.title) {
    console.error('No title given!')
    process.exit(1)
    return
  }

  if (!options.topic) {
    console.error('No topic given!')
    process.exit(1)
    return
  }

  if (!(await topicExists(options.topic))) {
    console.error(`The topic "${options.topic}" does not exists`)
    process.exit(1)
    return
  }

  const date = new Date()

  const dir = path.resolve(
    __dirname,
    `../src/entries/${options.topic}/${dateFns.format(date, 'yyyy-MM-dd')}-${makeSlug(options.title, '-')}`
  )
  try {
    await fs.promises.access(dir, fs.constants.F_OK)
    console.error(`A entry already named '${options.title}' already exists for today`)
    return
  } catch (error) {
    const publishedAt = date.toISOString()
    const text = '_Content goes here_'
    const mdx = `---\ntitle: ${
      options.title
    }\npublishedAt: ${publishedAt}\n\ncover:\n  image: full.jpg\n  caption: Starter caption.\n---\n\n${text}\n`

    await fs.promises.mkdir(dir, { recursive: true })

    const file = `${dir}/index.mdx`
    await fs.promises.writeFile(file, mdx)

    console.log(`Created a new entry: ${file.replace(path.resolve(__dirname, '..'), '')}`)
  }
}

async function instagram(topic: string, pathname: string) {
  const [_null, _p, id] = pathname.split('/')

  const { data } = await axios.get(`https://www.instagram.com${pathname}`)

  const $ = cheerio.load(data)
  const json = $('script[type="application/ld+json"]').html()

  if (!json) {
    console.error(`Photo data was not found for: ${path}`)
    process.exit(1)
    return
  }

  const schema = JSON.parse(json)

  const date = dateFns.parseISO(schema.uploadDate)

  const alt = `A photo taken in ${schema.contentLocation.name}`
  const publishedAt = date.toISOString()
  const text = dePants(schema.caption)
  const url = `https://www.instagram.com${pathname}`
  const mdx = `---\npublishedAt: ${publishedAt}\n\ninstagram:\n  url: ${url}\n---\n\n<!-- prettier-ignore-start -->\n! ![${alt}](${id}.jpg)\n! ${text}\n\n<!-- prettier-ignore-end -->\n`

  const dir = await uniqueNote(topic, date)
  await fs.promises.mkdir(dir, { recursive: true })

  const file = `${dir}/index.mdx`
  await fs.promises.writeFile(file, mdx)

  const image = `${dir}/${id}.jpg`
  const writer = fs.createWriteStream(image)
  const response = await axios.get(`https://www.instagram.com${pathname}media?size=l`, { responseType: 'stream' })

  response.data.pipe(writer)

  writer.on('error', console.error)
  writer.on('finish', () => {
    console.log(`Imported Instagram post to: ${file.replace(path.resolve(__dirname, '..'), '')}`)
  })
}

export async function generator(values: IFetcherValues) {
  const baseURN = 'urn:mordac:feed:'
  const xw = new XMLWriter(true)
  const aw = new ATOMWriter(xw)

  // Generate a full, standalone, XML document.
  xw.startDocument('1.0', 'utf-8')

  // Generate the feed header.
  aw
    .startFeed(baseURN + 'atom.xml')
    .writeTitle('Mordac’s RSS feed')
    .writeAuthor('Scott Adams')
    .writeContributor('Mordac the Preventer of Information Services')

  // Generate an entry for each value.
  for (const day of Object.keys(values)) {
    // Generate a fake timestamp for each post, so feed readers do not
    // consider them new/updated accidentally.
    const date = new Date(day + 'T13:37:00Z')

    const value: IParserExtractedValues = values[day]

    if (value && value.largeImage && value.largeImage.url) {
      aw
        .startEntry(baseURN + 'entry:' + day, date, date)
        .writeContent(htmlImageFragment(value.largeImage), 'html')

      if (value.largeImage.title) {
        aw.writeTitle(value.largeImage.title)
      }

      aw.endEntry()
    }
  }

  aw.endFeed()
  xw.endDocument()

  await fs.promises.writeFile(outputDir + '/atom.xml', xw.toString())
}