feat(glob): allow passing a glob pattern

Author: skovy

lib/cli.ts

@@ -1,10 +1,11 @@
 import yargs from "yargs";
 
-import { parse, Aliases, NAME_FORMATS, NameFormat } from "./sass";
+import { Aliases, NAME_FORMATS, NameFormat } from "./sass";
+import { main } from "./main";
 
 const nameFormatDefault: NameFormat = "camel";
 
-const { _: files, includePaths, aliases, nameFormat } = yargs
+const { _: patterns, includePaths, aliases, nameFormat } = yargs
   .demandOption("_")
   .option("aliases", { coerce: (obj): Aliases => obj, alias: "a" })
   .option("nameFormat", {
@@ -14,4 +15,4 @@ const { _: files, includePaths, aliases, nameFormat } = yargs
   })
   .option("includePaths", { array: true, string: true }).argv;
 
-parse(files[0], { includePaths, aliases, nameFormat });
+main(patterns[0], { includePaths, aliases, nameFormat });

lib/main.ts

@@ -0,0 +1,51 @@
+import { SassError } from "node-sass";
+import fs from "fs";
+import path from "path";
+import glob from "glob";
+import chalk from "chalk";
+
+import { Options, fileToClassNames } from "./sass";
+import { classNamesToTypeDefinitions } from "./typescript";
+
+const error = (message: string) => console.log(chalk.red(`[ERROR] ${message}`));
+const notice = (message: string) => console.log(chalk.gray(`${message}`));
+const success = (message: string) => console.log(chalk.green(message));
+
+export const main = (pattern: string, options: Options): void => {
+  const files = glob.sync(pattern);
+
+  if (!files || !files.length) {
+    error("No files found.");
+    return;
+  }
+
+  if (files.length === 1) {
+    notice(
+      'Only 1 file found. If using a glob pattern (eg: dir/**/*.scss) make sure to wrap in quotes (eg: "dir/**/*.scss").'
+    );
+  }
+
+  success(`Found ${files.length} files. Generating type defintions...`);
+
+  for (let index in files) {
+    const file = files[index];
+
+    fileToClassNames(file, options)
+      .then(classNames => {
+        const typeDefinition = classNamesToTypeDefinitions(classNames);
+        const path = `${file}.d.ts`;
+
+        if (!typeDefinition) {
+          notice(`No types generated for ${file}`);
+          return null;
+        }
+
+        fs.writeFileSync(path, typeDefinition);
+        success(`Generated type defintions: ${path}`);
+      })
+      .catch(({ message, file, line, column }: SassError) => {
+        const location = file ? `(${file}[${line}:${column}])` : "";
+        error(`${message} ${location}`);
+      });
+  }
+};

lib/sass/index.ts

@@ -1,2 +1,7 @@
-export { Aliases, NameFormat, NAME_FORMATS } from "./file-to-class-names";
-export { parse } from "./parse";
+export {
+  Aliases,
+  NameFormat,
+  NAME_FORMATS,
+  Options,
+  fileToClassNames
+} from "./file-to-class-names";

lib/sass/parse.ts

@@ -5,7 +5,13 @@ describe("classNamesToTypeDefinitions", () => {
     const definition = classNamesToTypeDefinitions(["myClass", "yourClass"]);
 
     expect(definition).toEqual(
-      "export const myClass: string;\nexport const yourClass: string;"
+      "export const myClass: string;\nexport const yourClass: string;\n"
     );
   });
+
+  it("returns null if there are no class names", () => {
+    const definition = classNamesToTypeDefinitions([]);
+
+    expect(definition).toBeNull;
+  });
 });

lib/typescript/__tests__/class-names-to-type-definitions.test.ts

@@ -1,9 +1,17 @@
-import { ClassNames } from "lib/sass/file-to-class-names";
+import { ClassNames, ClassName } from "lib/sass/file-to-class-names";
 
-export const classNamesToTypeDefinitions = (classNames: ClassNames): string => {
-  return (
-    classNames
-      .map(className => `export const ${className}: string;`)
-      .join("\n") + "\n"
-  );
+const classNameToTypeDefinition = (className: ClassName) =>
+  `export const ${className}: string;`;
+
+export const classNamesToTypeDefinitions = (
+  classNames: ClassNames
+): string | null => {
+  if (classNames.length) {
+    const typeDefinitions = classNames.map(classNameToTypeDefinition);
+
+    // Sepearte all type definitions be a newline with a trailing newline.
+    return typeDefinitions.join("\n") + "\n";
+  } else {
+    return null;
+  }
 };

lib/typescript/class-names-to-type-definition.ts

@@ -0,0 +1 @@
+export { classNamesToTypeDefinitions } from "./class-names-to-type-definition"