styles-config 2.0.0-alpha.4 → 2.0.0-alpha.6

package/src/loader.ts

@@ -1,112 +0,0 @@
-import { cosmiconfig, cosmiconfigSync, defaultLoadersSync } from 'cosmiconfig';
-import type { StylesConfig } from './types.js';
-
-export interface LoadedConfigMeta {
-  config: StylesConfig;
-  configFilePath?: string;
-}
-
-const explorer = cosmiconfig('styles', {
-  searchPlaces: [
-    'styles.config.ts',
-    'styles.config.js',
-    'styles.config.mts',
-    'styles.config.mjs',
-    'styles.config.cjs',
-    'styles.config.cts'
-  ],
-  loaders: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.mts': defaultLoadersSync['.ts'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.cts': defaultLoadersSync['.ts'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.mjs': defaultLoadersSync['.js'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.cjs': defaultLoadersSync['.cjs']
-  }
-});
-
-const explorerSync = cosmiconfigSync('styles', {
-  searchPlaces: [
-    'styles.config.ts',
-    'styles.config.js',
-    'styles.config.mts',
-    'styles.config.mjs',
-    'styles.config.cjs',
-    'styles.config.cts'
-  ],
-  loaders: {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.mts': defaultLoadersSync['.ts'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.cts': defaultLoadersSync['.ts'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.mjs': defaultLoadersSync['.js'],
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    '.cjs': defaultLoadersSync['.cjs']
-  }
-});
-
-/**
- * Load styles configuration from the file system (async)
- * @param searchFrom - Directory to search from (defaults to process.cwd())
- * @returns Configuration object or null if not found
- */
-export async function loadConfig(searchFrom?: string): Promise<StylesConfig | null> {
-  const result = await explorer.search(searchFrom);
-  return result?.config ? normalizeConfig(result.config) : null;
-}
-
-/**
- * Load styles configuration from the file system (sync)
- * @param searchFrom - Directory to search from (defaults to process.cwd())
- * @returns Configuration object or empty object if not found
- */
-export function loadConfigSync(searchFrom?: string): StylesConfig {
-  const result = explorerSync.search(searchFrom);
-  return result?.config ? normalizeConfig(result.config) : {};
-}
-
-/**
- * Load styles configuration with metadata (sync).
- * Includes config file path when a config file is discovered.
- */
-export function loadConfigSyncWithMeta(searchFrom?: string): LoadedConfigMeta {
-  const result = explorerSync.search(searchFrom);
-  return {
-    config: result?.config ? normalizeConfig(result.config) : {},
-    configFilePath: result?.filepath
-  };
-}
-
-/**
- * Load styles configuration from a specific file path (async)
- * @param filePath - Path to the config file
- * @returns Configuration object or null if not found
- */
-export async function loadConfigFromPath(filePath: string): Promise<StylesConfig | null> {
-  const result = await explorer.load(filePath);
-  return result?.config ? normalizeConfig(result.config) : null;
-}
-
-/**
- * Load styles configuration from a specific file path (sync)
- * @param filePath - Path to the config file
- * @returns Configuration object or empty object if not found
- */
-export function loadConfigFromPathSync(filePath: string): StylesConfig {
-  const result = explorerSync.load(filePath);
-  return result?.config ? normalizeConfig(result.config) : {};
-}
-
-/**
- * Normalize config object - handle default exports and ensure proper type
- */
-function normalizeConfig(config: any): StylesConfig {
-  // Handle default export (common in ES modules)
-  if (typeof config === 'object' && config !== null && 'default' in config) {
-    return config.default as StylesConfig;
-  }
-  return config as StylesConfig;
-}

package/src/options.ts

@@ -1,172 +0,0 @@
-import type { StylesConfig, FileMatchOptions } from './types.js';
-import picomatch from 'picomatch';
-import path from 'path';
-
-/**
- * Options for retrieving merged configuration
- */
-export interface GetOptionsParams {
-  /**
-   * Language key to get options for (e.g., 'less', 'scss', 'jess').
-   * If omitted but `input` is provided, language is inferred from the file extension.
-   */
-  language?: string;
-  /**
-   * Input file path to match against input options.
-   * Also used to infer language if `language` is not specified.
-   */
-  input?: string;
-  /**
-   * Output file path to match against output options
-   */
-  output?: string;
-}
-
-/**
- * Map of file extensions to language keys
- */
-const extensionToLanguage = new Map<string, string>([
-  ['.less', 'less'],
-  ['.scss', 'scss'],
-  ['.sass', 'scss'],
-  ['.jess', 'jess'],
-  ['.css', 'css']
-]);
-
-/**
- * Infer language from a file path's extension
- */
-function inferLanguage(filePath: string | undefined): string | undefined {
-  if (!filePath) {
-    return undefined;
-  }
-  const ext = path.extname(filePath).toLowerCase();
-  return extensionToLanguage.get(ext);
-}
-
-/**
- * Check if a file path matches a pattern (exact path, relative path, or glob)
- */
-function matchesFile(pattern: string | undefined, filePath: string | undefined): boolean {
-  if (!pattern || !filePath) {
-    return false;
-  }
-
-  // Normalize paths for comparison
-  const normalizedPattern = path.normalize(pattern);
-  const normalizedFile = path.normalize(filePath);
-
-  // Try exact match first
-  if (normalizedPattern === normalizedFile) {
-    return true;
-  }
-
-  // Try basename match (e.g., pattern "styles.less" matches "/path/to/styles.less")
-  if (path.basename(normalizedFile) === normalizedPattern) {
-    return true;
-  }
-
-  // Try glob/pattern match using picomatch
-  const isMatch = picomatch(pattern, { dot: true });
-  return isMatch(filePath) || isMatch(normalizedFile);
-}
-
-/**
- * Get matching options from an array of file-based options.
- * Returns merged options from:
- * 1. All entries without a `file` property (defaults)
- * 2. All entries whose `file` pattern matches the given path
- *
- * Later entries override earlier ones.
- */
-function getMatchingOptions<T extends FileMatchOptions>(
-  options: T | T[] | undefined,
-  filePath?: string
-): Partial<T> {
-  if (!options) {
-    return {};
-  }
-
-  const optionsArray = Array.isArray(options) ? options : [options];
-  let result: Partial<T> = {};
-
-  for (const opt of optionsArray) {
-    // Include if: no file pattern (default), or file pattern matches
-    if (!opt.file || (filePath && matchesFile(opt.file, filePath))) {
-      // Merge this entry's options, excluding the 'file' property
-      const rest = { ...opt } as Record<string, unknown>;
-      delete rest.file;
-      result = { ...result, ...rest };
-    }
-  }
-
-  return result;
-}
-/**
- * Get merged options by combining compile, language, input, and output settings.
- *
- * Merge priority (later wins):
- * 1. compile options (base)
- * 2. language-specific options (inferred from input extension or explicitly specified)
- * 3. matched input options (if input path provided and matches)
- * 4. matched output options (if output path provided and matches)
- *
- * @param config - The styles configuration object
- * @param params - Options specifying language, input file, and output file
- * @returns Merged options object
- *
- * @example
- * // Get Less options for a specific input/output (language inferred from .less extension)
- * const options = getOptions(config, {
- *   input: 'src/styles/main.less',
- *   output: 'dist/main.css'
- * });
- *
- * @example
- * // Explicitly specify language
- * const options = getOptions(config, { language: 'less' });
- *
- * @example
- * // Get base options without language-specific settings
- * const options = getOptions(config);
- */
-export function getOptions(
-  config: StylesConfig = {},
-  params: GetOptionsParams = {}
-): Record<string, any> {
-  const { input: inputFile, output: outputFile } = params;
-  const { compile = {}, input, output, language: languageConfig = {} } = config;
-
-  // Determine language: explicit param > inferred from input extension
-  const language = params.language ?? inferLanguage(inputFile);
-
-  // Get language-specific options if language is determined
-  const languageOptions = language ? (languageConfig[language] ?? {}) : {};
-
-  // Get matched input and output options
-  const matchedInput = getMatchingOptions(input, inputFile);
-  const matchedOutput = getMatchingOptions(output, outputFile);
-
-  // Build result with proper merge priority:
-  // 1. compile (base)
-  // 2. language-specific
-  // 3. matched input
-  // 4. matched output
-  return {
-    // Start with compile-level settings
-    mathMode: compile.mathMode,
-    unitMode: compile.unitMode,
-    equalityMode: compile.equalityMode,
-    paths: compile.searchPaths,
-    javascriptEnabled: compile.enableJavaScript,
-
-    // Override with language-specific settings
-    ...languageOptions,
-
-    // Override with matched input settings
-    ...matchedInput,
-
-    // Override with matched output settings
-    ...matchedOutput
-  };
-}

package/test/options.test.ts

@@ -1,256 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getOptions } from '../src/options.js';
-import type { StylesConfig } from '../src/types.js';
-
-describe('getOptions', () => {
-  describe('language inference from input extension', () => {
-    it('should infer language from .less extension', () => {
-      const config: StylesConfig = {
-        language: {
-          less: { leakyRules: true }
-        }
-      };
-      const options = getOptions(config, { input: 'src/styles.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should infer language from .scss extension', () => {
-      const config: StylesConfig = {
-        language: {
-          scss: { precision: 10 }
-        }
-      };
-      const options = getOptions(config, { input: 'src/styles.scss' });
-      expect(options.precision).toBe(10);
-    });
-
-    it('should infer language from .sass extension', () => {
-      const config: StylesConfig = {
-        language: {
-          scss: { indentedSyntax: true }
-        }
-      };
-      const options = getOptions(config, { input: 'src/styles.sass' });
-      expect(options.indentedSyntax).toBe(true);
-    });
-
-    it('should infer language from .jess extension', () => {
-      const config: StylesConfig = {
-        language: {
-          jess: { customOption: 'value' }
-        }
-      };
-      const options = getOptions(config, { input: 'src/styles.jess' });
-      expect(options.customOption).toBe('value');
-    });
-
-    it('should allow explicit language to override inferred', () => {
-      const config: StylesConfig = {
-        language: {
-          less: { leakyRules: true },
-          scss: { precision: 10 }
-        }
-      };
-      // File is .less but we explicitly request scss options
-      const options = getOptions(config, { language: 'scss', input: 'src/styles.less' });
-      expect(options.precision).toBe(10);
-      expect(options.leakyRules).toBeUndefined();
-    });
-  });
-
-  describe('merge priority', () => {
-    it('should merge compile options as base', () => {
-      const config: StylesConfig = {
-        compile: {
-          mathMode: 'parens-division',
-          unitMode: 'loose',
-          equalityMode: 'coerce'
-        }
-      };
-      const options = getOptions(config);
-      expect(options.mathMode).toBe('parens-division');
-      expect(options.unitMode).toBe('loose');
-      expect(options.equalityMode).toBe('coerce');
-    });
-
-    it('should override compile options with language options', () => {
-      const config: StylesConfig = {
-        compile: {
-          mathMode: 'parens-division'
-        },
-        language: {
-          less: { mathMode: 'strict' }
-        }
-      };
-      const options = getOptions(config, { language: 'less' });
-      expect(options.mathMode).toBe('strict');
-    });
-
-    it('should override language options with matched input options', () => {
-      const config: StylesConfig = {
-        language: {
-          less: { mathMode: 'parens-division', leakyRules: true }
-        },
-        input: [
-          { mathMode: 'strict' }
-        ]
-      };
-      const options = getOptions(config, { input: 'src/styles.less' });
-      expect(options.mathMode).toBe('strict');
-      expect(options.leakyRules).toBe(true); // from language.less
-    });
-
-    it('should override input options with matched output options', () => {
-      const config: StylesConfig = {
-        input: [
-          { compress: false }
-        ],
-        output: [
-          { compress: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'src/styles.less', output: 'dist/styles.css' });
-      expect(options.compress).toBe(true);
-    });
-
-    it('should apply full merge priority chain', () => {
-      const config: StylesConfig = {
-        compile: {
-          mathMode: 'always',
-          unitMode: 'loose',
-          equalityMode: 'coerce'
-        },
-        language: {
-          less: {
-            mathMode: 'parens-division',
-            leakyRules: true
-          }
-        },
-        input: [
-          { mathMode: 'strict', collapseNesting: false }
-        ],
-        output: [
-          { compress: true, sourceMap: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'src/styles.less', output: 'dist/styles.css' });
-      expect(options.unitMode).toBe('loose'); // from compile
-      expect(options.equalityMode).toBe('coerce'); // from compile
-      expect(options.leakyRules).toBe(true); // from language.less
-      expect(options.mathMode).toBe('strict'); // from input (overrides language)
-      expect(options.collapseNesting).toBe(false); // from input
-      expect(options.compress).toBe(true); // from output
-      expect(options.sourceMap).toBe(true); // from output
-    });
-  });
-
-  describe('file matching', () => {
-    it('should match entries without file property as defaults', () => {
-      const config: StylesConfig = {
-        input: [
-          { leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'any/file.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should match exact file paths', () => {
-      const config: StylesConfig = {
-        input: [
-          { leakyRules: false },
-          { file: 'src/legacy.less', leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'src/legacy.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should match basename patterns', () => {
-      const config: StylesConfig = {
-        input: [
-          { leakyRules: false },
-          { file: 'legacy.less', leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: '/path/to/legacy.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should match glob patterns', () => {
-      const config: StylesConfig = {
-        input: [
-          { leakyRules: false },
-          { file: 'legacy/**/*.less', leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'legacy/old/styles.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should not match when glob does not match', () => {
-      const config: StylesConfig = {
-        input: [
-          { leakyRules: false },
-          { file: 'legacy/**/*.less', leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'modern/styles.less' });
-      expect(options.leakyRules).toBe(false);
-    });
-
-    it('should merge multiple matching entries in order', () => {
-      const config: StylesConfig = {
-        input: [
-          { mathMode: 'always', leakyRules: false },
-          { file: '**/*.less', mathMode: 'parens-division' },
-          { file: 'legacy/**/*.less', leakyRules: true }
-        ]
-      };
-      const options = getOptions(config, { input: 'legacy/old.less' });
-      expect(options.mathMode).toBe('parens-division'); // from **/*.less
-      expect(options.leakyRules).toBe(true); // from legacy/**/*.less
-    });
-
-    it('should match output files with glob patterns', () => {
-      const config: StylesConfig = {
-        output: [
-          { compress: false },
-          { file: '**/*.min.css', compress: true }
-        ]
-      };
-      const options = getOptions(config, { output: 'dist/styles.min.css' });
-      expect(options.compress).toBe(true);
-    });
-  });
-
-  describe('single object vs array', () => {
-    it('should handle single input object', () => {
-      const config: StylesConfig = {
-        input: { leakyRules: true }
-      };
-      const options = getOptions(config, { input: 'src/styles.less' });
-      expect(options.leakyRules).toBe(true);
-    });
-
-    it('should handle single output object', () => {
-      const config: StylesConfig = {
-        output: { compress: true }
-      };
-      const options = getOptions(config, { output: 'dist/styles.css' });
-      expect(options.compress).toBe(true);
-    });
-  });
-
-  describe('no config', () => {
-    it('should return empty-ish object with no config', () => {
-      const options = getOptions();
-      expect(options).toBeDefined();
-    });
-
-    it('should return empty-ish object with empty config', () => {
-      const options = getOptions({});
-      expect(options).toBeDefined();
-    });
-  });
-});

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./lib",
-    "rootDir": "./src",
-    "noEmit": false
-  },
-  "include": ["src/**/*"]
-}
-