Merge pull request #187 from mizdra/support-arbitrary-extensions

Support `--arbitraryExtensions` option

README.md

@@ -56,6 +56,7 @@ Options:
       --lessIncludePaths     The option compatible with less's `--include-path`.                                                     [array]
       --webpackResolveAlias  The option compatible with webpack's `resolve.alias`.                                                  [string]
       --postcssConfig        The option compatible with postcss's `--config`.                                                       [string]
+      --arbitraryExtensions  Generate `.d.css.ts` instead of `.css.d.ts`.                                          [boolean] [default: true]
       --cache                Only generate .d.ts and .d.ts.map for changed files.                                  [boolean] [default: true]
       --cacheStrategy        Strategy for the cache to use for detecting changed files.[choices: "content", "metadata"] [default: "content"]
       --logLevel             What level of logs to report.                            [choices: "debug", "info", "silent"] [default: "info"]

src/cli.test.ts

@@ -1,4 +1,5 @@
 import { parseArgv } from './cli.js';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 
 const baseArgs = ['node', 'hcm'];
 
@@ -56,6 +57,10 @@ describe('parseArgv', () => {
       'postcss.config.js',
     );
   });
+  test('--arbitraryExtensions', () => {
+    expect(parseArgv([...baseArgs, '1.css']).arbitraryExtensions).toBe(DEFAULT_ARBITRARY_EXTENSIONS);
+    expect(parseArgv([...baseArgs, '1.css', '--arbitraryExtensions']).arbitraryExtensions).toBe(true);
+  });
   test('--cache', () => {
     expect(parseArgv([...baseArgs, '1.css']).cache).toBe(true);
     expect(parseArgv([...baseArgs, '1.css', '--cache']).cache).toBe(true);

src/cli.ts

@@ -1,5 +1,6 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 import { type RunnerOptions } from './runner.js';
 import { getPackageJson } from './util.js';
 
@@ -56,6 +57,11 @@ export function parseArgv(argv: string[]): RunnerOptions {
       string: true,
       describe: "The option compatible with postcss's `--config`.",
     })
+    .option('arbitraryExtensions', {
+      type: 'boolean',
+      default: DEFAULT_ARBITRARY_EXTENSIONS,
+      describe: 'Generate `.d.css.ts` instead of `.css.d.ts`.',
+    })
     .option('cache', {
       type: 'boolean',
       default: true,
@@ -106,6 +112,7 @@ export function parseArgv(argv: string[]): RunnerOptions {
     lessIncludePaths: parsedArgv.lessIncludePaths?.map((item) => item.toString()),
     webpackResolveAlias: parsedArgv.webpackResolveAlias ? JSON.parse(parsedArgv.webpackResolveAlias) : undefined,
     postcssConfig: parsedArgv.postcssConfig,
+    arbitraryExtensions: parsedArgv.arbitraryExtensions,
     cache: parsedArgv.cache,
     cacheStrategy: parsedArgv.cacheStrategy,
     logLevel: parsedArgv.logLevel,

src/config.ts

@@ -0,0 +1 @@
+export const DEFAULT_ARBITRARY_EXTENSIONS = false;

src/emitter/dts.test.ts

@@ -9,7 +9,10 @@ const locator = new Locator();
 const isExternalFile = () => false;
 
 test('getDtsFilePath', () => {
-  expect(getDtsFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.css', false)).toBe('/app/src/dir/1.css.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.scss', false)).toBe('/app/src/dir/1.scss.d.ts');
+  expect(getDtsFilePath('/app/src/dir/1.css', true)).toBe('/app/src/dir/1.d.css.ts');
+  expect(getDtsFilePath('/app/src/dir/1.scss', true)).toBe('/app/src/dir/1.d.scss.ts');
 });
 
 describe('generateDtsContentWithSourceMap', () => {

src/emitter/dts.ts

@@ -1,5 +1,5 @@
 import { EOL } from 'os';
-import { basename } from 'path';
+import { basename, parse, join } from 'path';
 import camelcase from 'camelcase';
 import { SourceNode, type CodeWithSourceMap } from '../library/source-map/index.js';
 import { type Token } from '../locator/index.js';
@@ -9,10 +9,16 @@ import { getRelativePath, type DtsFormatOptions } from './index.js';
 /**
  * Get .d.ts file path.
  * @param filePath The path to the source file (i.e. `/dir/foo.css`). It is absolute.
+ * @param arbitraryExtensions Generate `.d.css.ts` instead of `.css.d.ts`.
  * @returns The path to the .d.ts file. It is absolute.
  */
-export function getDtsFilePath(filePath: string): string {
-  return filePath + '.d.ts';
+export function getDtsFilePath(filePath: string, arbitraryExtensions: boolean): string {
+  if (arbitraryExtensions) {
+    const { dir, name, ext } = parse(filePath);
+    return join(dir, name + '.d' + ext + '.ts');
+  } else {
+    return filePath + '.d.ts';
+  }
 }
 
 function dashesCamelCase(str: string): string {

src/emitter/index.ts

@@ -1,4 +1,5 @@
 import { dirname, isAbsolute, relative } from 'path';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from '../config.js';
 import { type Token } from '../locator/index.js';
 import { type LocalsConvention } from '../runner.js';
 import { exists } from '../util.js';
@@ -20,7 +21,16 @@ export function isSubDirectoryFile(fromDirectory: string, toFilePath: string): b
 }
 
 export type DtsFormatOptions = {
+  /**
+   * Style of exported class names.
+   * @default undefined
+   */
   localsConvention?: LocalsConvention;
+  /**
+   * Generate `.d.css.ts` instead of `.css.d.ts`.
+   * @default false
+   */
+  arbitraryExtensions?: boolean | undefined;
 };
 
 /** The options for emitter. */
@@ -44,8 +54,9 @@ export async function emitGeneratedFiles({
   dtsFormatOptions,
   isExternalFile,
 }: EmitterOptions): Promise<void> {
-  const dtsFilePath = getDtsFilePath(filePath);
-  const sourceMapFilePath = getSourceMapFilePath(filePath);
+  const arbitraryExtensions = dtsFormatOptions?.arbitraryExtensions ?? DEFAULT_ARBITRARY_EXTENSIONS;
+  const dtsFilePath = getDtsFilePath(filePath, arbitraryExtensions);
+  const sourceMapFilePath = getSourceMapFilePath(filePath, arbitraryExtensions);
   const { dtsContent, sourceMap } = generateDtsContentWithSourceMap(
     filePath,
     dtsFilePath,
@@ -72,9 +83,10 @@ export async function emitGeneratedFiles({
 export async function isGeneratedFilesExist(
   filePath: string,
   emitDeclarationMap: boolean | undefined,
+  arbitraryExtensions: boolean,
 ): Promise<boolean> {
-  const dtsFilePath = getDtsFilePath(filePath);
-  const sourceMapFilePath = getSourceMapFilePath(filePath);
+  const dtsFilePath = getDtsFilePath(filePath, arbitraryExtensions);
+  const sourceMapFilePath = getSourceMapFilePath(filePath, arbitraryExtensions);
   if (emitDeclarationMap && !(await exists(sourceMapFilePath))) {
     return false;
   }

src/emitter/source-map.test.ts

@@ -2,7 +2,10 @@ import { EOL } from 'os';
 import { getSourceMapFilePath, generateSourceMappingURLComment } from './source-map.js';
 
 test('getSourceMapFilePath', () => {
-  expect(getSourceMapFilePath('/app/src/dir/1.css')).toBe('/app/src/dir/1.css.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.css', false)).toBe('/app/src/dir/1.css.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.scss', false)).toBe('/app/src/dir/1.scss.d.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.css', true)).toBe('/app/src/dir/1.d.css.ts.map');
+  expect(getSourceMapFilePath('/app/src/dir/1.scss', true)).toBe('/app/src/dir/1.d.scss.ts.map');
 });
 
 test('generateSourceMappingURLComment', () => {

src/emitter/source-map.ts

@@ -5,10 +5,11 @@ import { getRelativePath } from './index.js';
 /**
  * Get .d.ts.map file path.
  * @param filePath The path to the source file (i.e. `foo.css`). It is absolute.
+ * @param arbitraryExtensions Generate `.d.css.ts` instead of `.css.d.ts`.
  * @returns The path to the .d.ts.map file. It is absolute.
  */
-export function getSourceMapFilePath(filePath: string): string {
-  return getDtsFilePath(filePath) + '.map';
+export function getSourceMapFilePath(filePath: string, arbitraryExtensions: boolean): string {
+  return getDtsFilePath(filePath, arbitraryExtensions) + '.map';
 }
 
 export function generateSourceMappingURLComment(dtsFilePath: string, sourceMapFilePath: string): string {

src/runner.ts

@@ -7,6 +7,7 @@ import AwaitLock from 'await-lock';
 import chalk from 'chalk';
 import * as chokidar from 'chokidar';
 import _glob from 'glob';
+import { DEFAULT_ARBITRARY_EXTENSIONS } from './config.js';
 import { isGeneratedFilesExist, emitGeneratedFiles } from './emitter/index.js';
 import { Locator } from './locator/index.js';
 import { Logger } from './logger.js';
@@ -26,6 +27,10 @@ export type LocalsConvention = 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashe
 export interface RunnerOptions {
   pattern: string;
   watch?: boolean | undefined;
+  /**
+   * Style of exported class names.
+   * @default undefined
+   */
   localsConvention?: LocalsConvention | undefined;
   declarationMap?: boolean | undefined;
   transformer?: Transformer | undefined;
@@ -55,6 +60,11 @@ export interface RunnerOptions {
    * @example '/home/user/repository/src'
    */
   postcssConfig?: string | undefined;
+  /**
+   * Generate `.d.css.ts` instead of `.css.d.ts`.
+   * @default false
+   */
+  arbitraryExtensions?: boolean | undefined;
   /**
    * Only generate .d.ts and .d.ts.map for changed files.
    * @default true
@@ -126,7 +136,11 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
     await lock.acquireAsync();
 
     try {
-      const _isGeneratedFilesExist = await isGeneratedFilesExist(filePath, options.declarationMap);
+      const _isGeneratedFilesExist = await isGeneratedFilesExist(
+        filePath,
+        options.declarationMap,
+        options.arbitraryExtensions ?? DEFAULT_ARBITRARY_EXTENSIONS,
+      );
       const _isChangedFile = await isChangedFile(filePath);
       // Generate .d.ts and .d.ts.map only when the file has been updated.
       // However, if .d.ts or .d.ts.map has not yet been generated, always generate.
@@ -142,6 +156,7 @@ export async function run(options: RunnerOptions): Promise<Watcher | void> {
         emitDeclarationMap: options.declarationMap,
         dtsFormatOptions: {
           localsConvention: options.localsConvention,
+          arbitraryExtensions: options.arbitraryExtensions,
         },
         isExternalFile,
       });