How to use tiny-glob - 10 common examples

export function showOutput(cwd, options = {}, compile = svelte.compile) {
	glob('**/*.svelte', { cwd }).forEach(file => {
		if (file[0] === '_') return;

		try {
			const { js } = compile(
				fs.readFileSync(`${cwd}/${file}`, 'utf-8'),
				Object.assign(options, {
					filename: file
				})
			);

			console.log( // eslint-disable-line no-console
				`\n>> ${colors.cyan().bold(file)}\n${addLineNumbers(js.code)}\n<< ${colors.cyan().bold(file)}`
			);
		} catch (err) {
			console.log(`failed to generate output: ${err.message}`);
		}

// this file will replace all the expected.js and expected-bundle.js files with
// their _actual equivalents. Only use it when you're sure that you haven't
// broken anything!
const fs = require("fs");
const glob = require("tiny-glob/sync.js");

glob("samples/*/_actual.json", { cwd: __dirname }).forEach(file => {
	const actual = fs.readFileSync(`${__dirname}/${file}`, "utf-8");
	fs.writeFileSync(
		`${__dirname}/${file.replace("_actual", "output")}`,
		actual
	);
});

// this file will replace all the expected.js and expected-bundle.js files with
// their _actual equivalents. Only use it when you're sure that you haven't
// broken anything!
const fs = require("fs");
const glob = require("tiny-glob/sync.js");

glob("samples/*/_actual*", { cwd: __dirname }).forEach(file => {
	const actual = fs.readFileSync(`${__dirname}/${file}`, "utf-8");
	fs.writeFileSync(
		`${__dirname}/${file.replace("_actual", "expected")}`,
		actual
	);
});

public async cleanOutput() {
    if (!(await pathExists(this.config.out))) {
      await ensureDir(this.config.out);
    } else if (this.config.cleanBeforeExport) {
      // Don't require prompt if force is true
      if (!this.config.force) {
        // Scan the output directory for important files, and prompt confirmation if yes
        if (this.terminal) {
          this.terminal.update({ text: `${DynamicTerminal.SPINNER} Checking output directory` });
        }

        // tiny-glob works with UNIX-style paths, even on Windows
        const cwd = isAbsolute(this.config.out) && platform() !== "win32" ? "/" : "";
        const files = await glob(posix.join(this.config.out, "/**/*"), {
          absolute: true,
          filesOnly: true,
          cwd
        });
        const knownExtensions = SUPPORTED_EXTENSIONS.map(ext => `.${ext}`).concat(".json");

        for (const file of files) {
          if (
            knownExtensions.indexOf(posix.parse(file).ext) === -1 &&
            !RegExp(/.rib-[0-9a-zA-Z]*/).test(file)
          ) {
            // Unknown file extension found, prompt clean
            if (this.terminal) {
              await this.terminal.stop(false);
              this.terminal.destroy(); // Worker would block program termination
            }

export async function getDefinitionModules({ config }) {
  const schemasExists = await exists(config.schemasPath)
  if (!schemasExists) return []
  const files = await glob('**/*.js', { cwd: config.schemasPath })
  const defs = files.map(relativePath => {
    const absolutePath = path.join(config.schemasPath, relativePath)
    if (!config.cache) {
      delete require.cache[absolutePath]
    }
    // eslint-disable-next-line global-require, import/no-dynamic-require
    return babelRequire(absolutePath)
  })

  return defs
}

result.error = `Not enough permissions to read the directory "${dir}"`;
        return result;
      }
    }

    this.update(line, DynamicTerminal.SPINNER + " Searching for images");

    // tiny-glob requires forward slashes
    // resolve all supported files and append them to the files array as a File object
    for (const dir of this.config.in) {
      try {
        if ((await stat(dir)).isFile()) {
          result.files.push({ base: posix.parse(dir).dir, path: dir });
        } else {
          const cwd = isAbsolute(dir) && platform() !== "win32" ? "/" : "";
          const files = await glob(
            posix.join(dir, "/**/*.{" + SUPPORTED_EXTENSIONS.join(",") + "}"),
            { absolute: true, cwd }
          );
          result.files.push(...files.map(p => ({ base: dir, path: cleanUpPath(p) })));
        }
        this.update(
          line,
          DynamicTerminal.SPINNER + " Searching for images (found " + result.files.length + ")"
        );
      } catch (err) {
        this.update(line, DynamicTerminal.CROSS + " Failed to search for images");
        result.error = "Failed to search for images\n" + chalk.white(err.message || err);
        return result;
      }
    }

);

			if (commandErr) {
				done(commandErr);
				return;
			}

			const actual = glob('**', { cwd: 'actual', filesOnly: true })
				.map(file => {
					return {
						file,
						contents: normalize(fs.readFileSync(`actual/${file}`, 'utf-8'))
					};
				});

			const expected = glob('**', { cwd: 'expected', filesOnly: true })
				.map(file => {
					return {
						file,
						contents: normalize(
							fs.readFileSync(`expected/${file}`, 'utf-8')
						)
					};
				});

			actual.forEach((a, i) => {
				const e = expected[i];

				assert.equal(a.file, e.file, 'File list mismatch');

				if (/\.map$/.test(a.file)) {
					assert.deepEqual(JSON.parse(a.contents), JSON.parse(e.contents));

Object.keys(require.cache)
				.filter(x => x.endsWith('.svelte'))
				.forEach(file => {
					delete require.cache[file];
				});

			delete global.window;

			const compileOptions = Object.assign({ sveltePath }, config.compileOptions, {
				generate: 'ssr',
				format: 'cjs'
			});

			require("../../register")(compileOptions);

			glob('**/*.svelte', { cwd }).forEach(file => {
				if (file[0] === '_') return;

				const dir  = `${cwd}/_output/ssr`;
				const out = `${dir}/${file.replace(/\.svelte$/, '.js')}`;

				if (fs.existsSync(out)) {
					fs.unlinkSync(out);
				}

				mkdirp(dir);

				try {
					const { js } = compile(
						fs.readFileSync(`${cwd}/${file}`, 'utf-8'),
						{
							...compileOptions,

compileOptions.accessors = 'accessors' in config ? config.accessors : true;

			Object.keys(require.cache)
				.filter(x => x.endsWith('.svelte'))
				.forEach(file => {
					delete require.cache[file];
				});

			let mod;
			let SvelteComponent;

			let unintendedError = null;

			const window = env();

			glob('**/*.svelte', { cwd }).forEach(file => {
				if (file[0] === '_') return;

				const dir  = `${cwd}/_output/${hydrate ? 'hydratable' : 'normal'}`;
				const out = `${dir}/${file.replace(/\.svelte$/, '.js')}`;

				if (fs.existsSync(out)) {
					fs.unlinkSync(out);
				}

				mkdirp(dir);

				try {
					const { js } = compile(
						fs.readFileSync(`${cwd}/${file}`, 'utf-8'),
						{
							...compileOptions,

import "jest-extended";

import { parse } from "path";
import tg from "tiny-glob/sync";

const entries = tg("../../../../packages/crypto/src/networks/**/*.json", { cwd: __dirname });

const NETWORKS = {};
entries.forEach(file => {
    NETWORKS[parse(file).name] = require(file);
});

const NETWORKS_LIST = [];
entries.forEach(file => NETWORKS_LIST.push(require(file)));

module.exports = { NETWORKS, NETWORKS_LIST };