fix: clear out old types for empty files

__tests__/core/write-file.test.ts

@@ -14,6 +14,9 @@ describeAllImplementations((implementation) => {
       // Avoid creating new directories while running tests.
       jest.spyOn(fs, "mkdirSync").mockImplementation();
 
+      // Test removing existing types.
+      jest.spyOn(fs, "unlinkSync").mockImplementation();
+
       console.log = jest.fn();
     });
 
@@ -74,6 +77,50 @@ describeAllImplementations((implementation) => {
       );
     });
 
+    describe("when a file already exists with type definitions", () => {
+      const testFile = path.resolve(__dirname, "..", "dummy-styles/empty.scss");
+      const existingTypes = path.join(
+        process.cwd(),
+        "__tests__/dummy-styles/empty.scss.d.ts"
+      );
+      const originalExistsSync = fs.existsSync;
+
+      beforeEach(() => {
+        jest
+          .spyOn(fs, "existsSync")
+          .mockImplementation((p) =>
+            p === existingTypes ? true : originalExistsSync(p)
+          );
+      });
+
+      afterEach(() => {
+        (fs.existsSync as jest.Mock).mockRestore();
+      });
+
+      test("it removes existing type definitions if no classes are found", async () => {
+        await writeFile(testFile, {
+          banner: "",
+          watch: false,
+          ignoreInitial: false,
+          exportType: "named",
+          exportTypeName: "ClassNames",
+          exportTypeInterface: "Styles",
+          listDifferent: false,
+          ignore: [],
+          implementation,
+          quoteType: "single",
+          updateStaleOnly: false,
+          logLevel: "verbose",
+          outputFolder: null,
+        });
+
+        expect(fs.unlinkSync).toBeCalledWith(existingTypes);
+        expect(console.log).toBeCalledWith(
+          expect.stringContaining(`[REMOVED] ${existingTypes}`)
+        );
+      });
+    });
+
     describe("when outputFolder is passed", () => {
       it("should write to the correct path", async () => {
         const testFile = path.resolve(

lib/core/write-file.ts

@@ -9,6 +9,7 @@ import {
 } from "../typescript";
 import { fileToClassNames } from "../sass";
 import { CLIOptions } from "./types";
+import { removeSCSSTypeDefinitionFile } from "./remove-file";
 
 /**
  * Given a single file generate the proper types.
@@ -24,17 +25,24 @@ export const writeFile = (file: string, options: CLIOptions): Promise<void> => {
         ...options,
       });
 
+      const typesPath = getTypeDefinitionPath(file, options);
+      const typesExist = fs.existsSync(typesPath);
+
+      // Avoid outputting empty type definition files.
+      // If the file exists and the type definition is now empty, remove the file.
       if (!typeDefinition) {
-        alerts.notice(`[NO GENERATED TYPES] ${file}`);
+        if (typesExist) {
+          removeSCSSTypeDefinitionFile(file, options);
+        } else {
+          alerts.notice(`[NO GENERATED TYPES] ${file}`);
+        }
         return;
       }
 
-      const typesPath = getTypeDefinitionPath(file, options);
-
       // Avoid re-writing the file if it hasn't changed.
       // First by checking the file modification time, then
       // by comparing the file contents.
-      if (options.updateStaleOnly && fs.existsSync(typesPath)) {
+      if (options.updateStaleOnly && typesExist) {
         const fileModified = fs.statSync(file).mtime;
         const typeDefinitionModified = fs.statSync(typesPath).mtime;