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

package/lib/types.d.ts

@@ -0,0 +1,385 @@
+/**
+ * Math processing modes
+ */
+export type MathMode = 'always' | 'parens-division' | 'parens' | 'strict';
+/**
+ * Unit conversion modes
+ */
+export type UnitMode = 'loose' | 'preserve' | 'strict';
+/**
+ * Function-call resolution modes — mirrors {@link UnitMode}. Governs an optional
+ * (global) function call that matched a registered function but couldn't be
+ * evaluated: `preserve` renders it as-is (+ warning), `error` throws.
+ */
+export type FunctionMode = 'preserve' | 'error';
+/**
+ * Equality dialects for guard comparisons — named by dialect (Less 4.x and Sass
+ * diverge in opposite directions), not by strictness:
+ * - `less`: Less 4.x equality (numeric coercion; quoted vs unquoted distinct)
+ * - `sass`: Dart Sass equality (unit-strict; quote-insensitive strings)
+ * - `exact`: no coercion — operands must be the same node type
+ */
+export type EqualityMode = 'less' | 'sass' | 'exact';
+export type ExtendSelectorKind = 'simple' | 'basic' | 'pseudo' | 'complex' | 'compound';
+/**
+ * Less compiler options
+ * Based on less.js default-options.js and bin/lessc
+ */
+export interface LessOptions {
+    /**
+     * Restrict which selector shapes are allowed in extend targets.
+     * When set, any other selector kind is a parse error.
+     */
+    allowExtendSelectors?: ExtendSelectorKind[];
+    /**
+     * Inline Javascript - @plugin still allowed
+     * @default false
+     */
+    javascriptEnabled?: boolean;
+    /**
+     * @deprecated Use `disableScriptModules` instead.
+     */
+    disablePluginRule?: boolean;
+    /**
+     * Outputs a makefile import dependency list to stdout.
+     * @default false
+     */
+    depends?: boolean;
+    /**
+     * @deprecated Compress using less built-in compression.
+     * This does an okay job but does not utilise all the tricks of
+     * dedicated css compression.
+     * @default false
+     */
+    compress?: boolean;
+    /**
+     * Runs the less parser and just reports errors without any output.
+     * @default false
+     */
+    lint?: boolean;
+    /**
+     * Sets available include paths.
+     * If the file in an @import rule does not exist at that exact location,
+     * less will look for it at the location(s) passed to this option.
+     * @default []
+     */
+    paths?: string[];
+    /**
+     * Color output in the terminal
+     * @default true
+     */
+    color?: boolean;
+    /**
+     * @deprecated This option has confusing behavior and may be removed in a future version.
+     *
+     * Controls how @import statements for .less files are handled inside selector blocks (rulesets).
+     *
+     * Behavior:
+     * - @import at root level: Always processed
+     * - @import inside @-rules (@media, @supports, etc.): Processed (these are not selector blocks)
+     * - @import inside selector blocks (.class, #id, etc.): Behavior depends on this option
+     *
+     * Options:
+     * - `false` (default): All @import statements are processed regardless of context.
+     * - `true`: @import statements inside selector blocks are silently ignored and not output.
+     * - `'error'`: @import statements inside selector blocks will throw an error instead of being silently ignored.
+     *
+     * Note: Only affects .less file imports. CSS imports (url(...) or .css files) are
+     * always output as CSS @import statements regardless of this setting.
+     *
+     * @see https://github.com/less/less.js/issues/656
+     * @default false
+     */
+    strictImports?: boolean | 'error';
+    /**
+     * Allow Imports from Insecure HTTPS Hosts
+     * @default false
+     */
+    insecure?: boolean;
+    /**
+     * Allows you to add a path to every generated import and url in your css.
+     * This does not affect less import statements that are processed, just ones
+     * that are left in the output css.
+     * @default ''
+     */
+    rootpath?: string;
+    /**
+     * By default URLs are kept as-is, so if you import a file in a sub-directory
+     * that references an image, exactly the same URL will be output in the css.
+     * This option allows you to re-write URL's in imported files so that the
+     * URL is always relative to the base imported file
+     * @default false
+     */
+    rewriteUrls?: boolean | 'all' | 'local' | 'off';
+    /**
+     * How to process math operations
+     * - 'always': eagerly try to solve all operations
+     * - 'parens-division': require parens for division "/"
+     * - 'parens' or 'strict': require parens for all operations
+     * @default 'parens-division'
+     */
+    mathMode?: MathMode;
+    /**
+     * How to handle unit conversions in math operations
+     * - 'loose': Less's default 1.x-4.x behavior
+     * - 'preserve': Create calc() expressions for unit errors
+     * - 'strict': strict unit mode
+     * @default 'preserve'
+     */
+    unitMode?: UnitMode;
+    /**
+     * How to handle an optional/global function call that matched a registered
+     * function but couldn't be evaluated (no matching signature, or it threw) —
+     * e.g. `unit(80/16)`, `color("x")`. Mirrors {@link unitMode}.
+     * - 'preserve': render the call as-is (like an unknown CSS function) + warn
+     * - 'error': throw the underlying function error (Less 4.x behavior)
+     * Unknown function names always render as-is regardless.
+     * @default 'preserve'
+     */
+    functionMode?: FunctionMode;
+    /**
+     * How to handle equality/coercion in guards and comparisons.
+     * - 'loose': Less-compatible loose (coercive) equality (JS '==')
+     * - 'strict': type-strict behavior
+     * @default 'loose'
+     */
+    equalityMode?: EqualityMode;
+    /**
+     * @deprecated Use `mathMode` instead. This option maps to `mathMode` as follows:
+     * - 0 or 'always' → 'always'
+     * - 1 or 'parens-division' → 'parens-division'
+     * - 2 or 'parens' or 'strict' → 'parens'
+     * - 3 or 'strict-legacy' → 'parens' (removed, will default to 'strict)
+     * @default undefined (uses mathMode if provided, otherwise 'parens-division')
+     */
+    math?: 0 | 1 | 2 | 3 | MathMode | 'strict-legacy';
+    /**
+     * @deprecated Use `unitMode` instead. If `true`, sets `unitMode` to 'strict'.
+     * If `false`, sets the unitMode to 'loose.
+     * If undefined, uses the `unitMode` value (defaults to 'preserve').
+     * @default false
+     */
+    strictUnits?: boolean;
+    /**
+     * Effectively the declaration is put at the top of your base Less file,
+     * meaning it can be used but it also can be overridden if this variable
+     * is defined in the file.
+     * @default null
+     */
+    globalVars?: Record<string, string> | null;
+    /**
+     * As opposed to the global variable option, this puts the declaration at the
+     * end of your base file, meaning it will override anything defined in your Less file.
+     * @default null
+     */
+    modifyVars?: Record<string, string> | null;
+    /**
+     * This option allows you to specify a argument to go on to every URL.
+     * @default ''
+     */
+    urlArgs?: string;
+    /**
+     * @removed The dumpLineNumbers option is not useful nor supported in browsers. Use sourcemaps instead.
+     *
+     * @default undefined
+     */
+    dumpLineNumbers?: string;
+    /**
+     * Source map options
+     * @default undefined
+     */
+    sourceMap?: boolean | {
+        sourceMapFullFilename?: string;
+        sourceMapRootpath?: string;
+        sourceMapBasepath?: string;
+        sourceMapURL?: string;
+        sourceMapFileInline?: boolean;
+        outputSourceFiles?: boolean;
+        disableSourcemapAnnotation?: boolean;
+        sourceMapOutputFilename?: string;
+        sourceMapFilename?: string;
+    };
+    /**
+     * Verbose output
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Silent mode (suppress errors)
+     * @default false
+     */
+    silent?: boolean;
+    /**
+     * Quiet mode (suppress warnings)
+     * @default false
+     */
+    quiet?: boolean;
+    /**
+     * Convenience preset. When `true`, sets the strict bundle for any of the
+     * following left `undefined` (individual options always win):
+     * - `unitMode: 'strict'`
+     * - `equalityMode: 'exact'` (the no-coercion dialect)
+     * - `leakyScope: false`
+     * - `allowOverloadedImport: false`
+     *
+     * Modeled after `tsconfig` `strict`: it only *sets* semantic options, it is not
+     * itself a mode.
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * Whether re-importing a file/namespace may contribute *overloaded* (duplicated,
+     * additively-merged) definitions rather than being de-duplicated like Less's
+     * `@import (once)`. `strict` sets this to `false`.
+     * @default true
+     */
+    allowOverloadedImport?: boolean;
+    /**
+     * @deprecated This is legacy Less behavior.
+     *
+     * Controls whether mixins and detached rulesets "leak" their inner rules.
+     * When true:
+     * - Mixins: Mixin and VarDeclaration nodes are 'public' and 'optional' respectively
+     * - Detached rulesets: Mixin and VarDeclaration nodes are 'public' and 'private' respectively
+     * When false:
+     * - Both mixins and detached rulesets: Mixin and VarDeclaration nodes are 'private'
+     * @default true
+     */
+    leakyScope?: boolean;
+    /**
+     * Whether to collapse nested selectors (Less 1.x-4.x style flattening)
+     * When true, nested selectors like `.parent { .child { } }` are flattened to `.parent .child { }`
+     * @default false
+     */
+    collapseNesting?: boolean;
+    /**
+     * @deprecated This is legacy Less behavior.
+     *
+     * Whether to bubble root-only at-rules (@font-face, @keyframes, etc.) to the root
+     * when they are nested inside rulesets. Modern CSS supports nesting these at-rules.
+     * @default true
+     */
+    bubbleRootAtRules?: boolean;
+}
+export interface ScssOptions {
+    allowExtendSelectors?: ExtendSelectorKind[];
+    unitMode?: UnitMode;
+    equalityMode?: EqualityMode;
+    collapseNesting?: boolean;
+    [key: string]: any;
+}
+/**
+ * Base interface for file-matching options
+ */
+export interface FileMatchOptions {
+    /**
+     * File path, relative path, or glob pattern for matching.
+     * If omitted, the options serve as defaults.
+     */
+    file?: string;
+}
+/**
+ * Input file options - can override compile and language settings per input file
+ */
+export interface InputOptions extends FileMatchOptions {
+    mathMode?: MathMode;
+    unitMode?: UnitMode;
+    functionMode?: FunctionMode;
+    equalityMode?: EqualityMode;
+    strict?: boolean;
+    allowOverloadedImport?: boolean;
+    allowExtendSelectors?: ExtendSelectorKind[];
+    disableScriptModules?: boolean;
+    /**
+     * @deprecated Use `disableScriptModules` instead.
+     */
+    disablePluginRule?: boolean;
+    searchPaths?: string[];
+    javascriptEnabled?: boolean;
+    paths?: string[];
+    globalVars?: Record<string, string> | null;
+    modifyVars?: Record<string, string> | null;
+    strictImports?: boolean | 'error';
+    rewriteUrls?: boolean | 'all' | 'local' | 'off';
+    rootpath?: string;
+    leakyScope?: boolean;
+    collapseNesting?: boolean;
+    bubbleRootAtRules?: boolean;
+    /** Allow additional language-specific options */
+    [key: string]: any;
+}
+/**
+ * Output file options - can override output settings per output file
+ */
+export interface OutputOptions extends FileMatchOptions {
+    collapseNesting?: boolean;
+    compress?: boolean;
+    sourceMap?: boolean | {
+        sourceMapFullFilename?: string;
+        sourceMapRootpath?: string;
+        sourceMapBasepath?: string;
+        sourceMapURL?: string;
+        sourceMapFileInline?: boolean;
+        outputSourceFiles?: boolean;
+        disableSourcemapAnnotation?: boolean;
+        sourceMapOutputFilename?: string;
+        sourceMapFilename?: string;
+    };
+    /** Allow additional options */
+    [key: string]: any;
+}
+export interface StylesConfig {
+    compile?: {
+        /**
+         * Plugins can be specified as:
+         * - Plugin instances (PluginInterface from @jesscss/core)
+         * - String keys (plugin names that get resolved elsewhere)
+         *
+         * @note - Using `any` here to avoid circular dependency with @jesscss/core.
+         *         The actual type is PluginInterface from @jesscss/core.
+         */
+        plugins?: Array<any | string>;
+        searchPaths?: string[];
+        mathMode?: MathMode;
+        unitMode?: UnitMode;
+        functionMode?: FunctionMode;
+        equalityMode?: EqualityMode;
+        /** See {@link LessOptions.strict}. Expanded onto the other compile modes. */
+        strict?: boolean;
+        /** See {@link LessOptions.allowOverloadedImport}. */
+        allowOverloadedImport?: boolean;
+        /** See {@link LessOptions.leakyScope}. */
+        leakyScope?: boolean;
+        allowExtendSelectors?: ExtendSelectorKind[];
+        disableScriptModules?: boolean;
+        /**
+         * @deprecated Use `disableScriptModules` instead.
+         */
+        disablePluginRule?: boolean;
+        /**
+         * Filesystem root that Less `@plugin` / script-module scripts are allowed to
+         * be read from. When set, it overrides the default (the entry file's
+         * directory). Paths outside this root are rejected by @jesscss/plugin-js.
+         */
+        jsReadRoot?: string;
+    };
+    /**
+     * Input file options. Can be a single object for defaults, or an array
+     * where entries can have a `file` property (path or glob) to match specific inputs.
+     * Entries without a `file` property serve as defaults.
+     */
+    input?: InputOptions | InputOptions[];
+    /**
+     * Output file options. Can be a single object for defaults, or an array
+     * where entries can have a `file` property (path or glob) to match specific outputs.
+     * Entries without a `file` property serve as defaults.
+     */
+    output?: OutputOptions | OutputOptions[];
+    language?: {
+        less?: LessOptions;
+        scss?: ScssOptions;
+        css?: Record<string, any>;
+        jess?: Record<string, any>;
+        [key: string]: LessOptions | ScssOptions | Record<string, any> | undefined;
+    };
+}

package/package.json

@@ -4,14 +4,13 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.0.0-alpha.6",
+  "version": "2.0.0-alpha.7",
   "description": "General-purpose configuration for styling frameworks (Jess, Less, Sass, Tailwind, etc.)",
   "main": "lib/index.cjs",
   "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
-      "source": "./src/index.ts",
       "import": "./lib/index.js",
       "require": "./lib/index.cjs"
     }
@@ -22,7 +21,7 @@
   "dependencies": {
     "cosmiconfig": "^9.0.0",
     "picomatch": "^4.0.2",
-    "@jesscss/core": "2.0.0-alpha.6"
+    "@jesscss/core": "2.0.0-alpha.7"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
@@ -35,7 +34,7 @@
   "module": "lib/index.js",
   "scripts": {
     "build": "pnpm compile",
-    "compile": "tsdown --tsconfig tsconfig.build.json && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "compile": "tsdown --tsconfig tsconfig.build.json --no-dts && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck",
     "test": "vitest"
   }
 }