@visulima/rollup-plugin-css 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/utils/array-fmt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Formats an array of strings into a human-readable list format.
+ *
+ * Converts an array into a grammatically correct string with proper conjunctions:
+ * - Single item: "`item`"
+ * - Two items: "`item1` or `item2`"
+ * - Multiple items: "`item1`, `item2`, or `item3`"
+ * @param array Array of strings to format
+ * @returns Formatted string with proper conjunctions and backticks
+ * @example
+ * ```typescript
+ * arrayFmt(['inject']) // "`inject`"
+ * arrayFmt(['inject', 'extract']) // "`inject` or `extract`"
+ * arrayFmt(['inject', 'extract', 'emit']) // "`inject`, `extract`, or `emit`"
+ * ```
+ */
+declare const arrayFmt: (array: string[]) => string;
+export default arrayFmt;

package/dist/utils/concat.d.ts

@@ -0,0 +1,34 @@
+import { SourceMapGenerator } from "source-map-js";
+import type { Extracted } from "../loaders/types.d.ts";
+interface Concatenated {
+    css: string;
+    map: SourceMapGenerator;
+}
+/**
+ * Concatenates multiple CSS data objects into a single unified object with source map support.
+ *
+ * This utility function merges CSS content from multiple sources while
+ * properly handling source maps and metadata. It's used during the build
+ * process to combine CSS from different modules or chunks while preserving
+ * accurate source mapping information for debugging.
+ *
+ * The function:
+ * - Concatenates CSS content with newline separators
+ * - Merges source maps from all inputs
+ * - Adjusts line/column mappings for the combined output
+ * - Preserves source content for debugging
+ * @param extracted Array of extracted CSS data objects to concatenate
+ * @returns Promise resolving to concatenated CSS with merged source maps
+ * @example
+ * ```typescript
+ * const extracted = [
+ *   { css: '.header {}', map: headerSourceMap },
+ *   { css: '.footer {}', map: footerSourceMap }
+ * ];
+ *
+ * const result = await concat(extracted);
+ * // Result: Combined CSS with properly merged source maps
+ * ```
+ */
+declare const concat: (extracted: Extracted[]) => Promise<Concatenated>;
+export default concat;

package/dist/utils/generate-js-exports.d.ts

@@ -0,0 +1,78 @@
+import type { InjectOptions } from "../types.d.ts";
+export interface JsExportOptions {
+    /** CSS content to export */
+    css: string;
+    /** Current working directory for relative path calculations */
+    cwd?: string;
+    /** Whether to generate TypeScript declarations */
+    dts?: boolean;
+    /** Whether to emit CSS instead of JavaScript */
+    emit?: boolean;
+    /** Whether to extract CSS to separate files */
+    extract?: boolean | string;
+    /** ICSS dependencies for CSS modules */
+    icssDependencies?: string[];
+    /** File ID for safe identifier generation */
+    id: string;
+    /** CSS injection configuration */
+    inject?: InjectOptions | boolean | ((varname: string, id: string, output: string[]) => string);
+    /** Whether to inline CSS as strings */
+    inline?: boolean;
+    /** Logger for warnings */
+    logger?: {
+        warn: (log: {
+            message: string;
+            plugin?: string;
+        }) => void;
+    };
+    /** Source map for the CSS */
+    map?: string;
+    /** CSS modules exports mapping class names to hashed names */
+    modulesExports: Record<string, string>;
+    /** Named exports configuration */
+    namedExports?: boolean | ((name: string) => string);
+    /** Whether CSS modules are supported */
+    supportModules: boolean;
+}
+export interface JsExportResult {
+    /** Generated JavaScript code */
+    code: string;
+    /** Extracted CSS data for file extraction */
+    extracted?: {
+        css: string;
+        id: string;
+        map?: string;
+    };
+    /** Source map */
+    map?: string;
+    /** Metadata including types and module contents */
+    meta?: {
+        icssDependencies?: string[];
+        moduleContents?: string;
+        types?: string;
+    };
+    /** Module side effects configuration */
+    moduleSideEffects: boolean | "no-treeshake";
+    /** Generated TypeScript declarations */
+    types?: string;
+}
+/**
+ * Generates JavaScript exports for CSS content with support for CSS modules and injection
+ * @param options Configuration options for export generation
+ * @param options.css CSS content to export
+ * @param options.cwd Current working directory for relative path calculations
+ * @param options.dts Whether to generate TypeScript declarations
+ * @param options.emit Whether to emit CSS instead of JavaScript
+ * @param options.extract Whether to extract CSS to separate files
+ * @param options.icssDependencies ICSS dependencies for CSS modules
+ * @param options.id File ID for safe identifier generation
+ * @param options.inject CSS injection configuration
+ * @param options.inline Whether to inline CSS as strings
+ * @param options.logger Logger for warnings
+ * @param options.map Source map for the CSS
+ * @param options.modulesExports CSS modules exports mapping class names to hashed names
+ * @param options.namedExports Named exports configuration
+ * @param options.supportModules Whether CSS modules are supported
+ * @returns Generated JavaScript code and TypeScript declarations
+ */
+export declare const generateJsExports: ({ css, cwd, dts, emit, extract, icssDependencies, id, inject, inline, logger, map, modulesExports, namedExports, supportModules, }: JsExportOptions) => JsExportResult;

package/dist/utils/index.d.ts

@@ -1,73 +1,9 @@
-import { SourceMapGenerator, RawSourceMap, SourceMapConsumer } from 'source-map-js';
-import { h as Extracted, b as PostCSSOptions, S as StyleOptions, a as InternalStyleOptions, i as LoaderContext } from '../packem_shared/types-CA9pSumu.js';
-import { RollupLogger } from '@visulima/packem-share/utils';
-import { Result } from 'postcss-load-config';
-import { NapiResolveOptions } from 'oxc-resolver';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'less';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import 'rollup';
-
-declare const arrayFmt: (array: string[]) => string;
-
-interface Concatenated {
-    css: string;
-    map: SourceMapGenerator;
-}
-declare const concat: (extracted: Extracted[]) => Promise<Concatenated>;
-
-declare const loadModule: (moduleId: string, cwd: string, logger: RollupLogger) => Promise<any>;
-
-interface Mode {
-    emit: InternalStyleOptions["emit"];
-    extract: InternalStyleOptions["extract"];
-    inject: InternalStyleOptions["inject"];
-    inline: InternalStyleOptions["inline"];
-}
-type PCSSOption = "parser" | "plugin" | "stringifier" | "syntax";
-declare const inferModeOption: (mode: StyleOptions["mode"]) => Mode;
-declare const inferOption: <T, TDefine extends T | boolean | undefined>(option: T | boolean | undefined, defaultValue: TDefine) => OptionType<T, TDefine>;
-declare const inferSourceMapOption: (sourceMap: StyleOptions["sourceMap"]) => LoaderContext["sourceMap"];
-declare const inferHandlerOption: <T extends {
-    alias?: Record<string, string>;
-}>(option: T | boolean | undefined, alias: T["alias"]) => T | false;
-declare const ensurePCSSOption: <T>(option: T | string, type: PCSSOption, cwd: string, logger: RollupLogger) => Promise<T>;
-declare const ensurePCSSPlugins: (plugins: PostCSSOptions["plugins"], cwd: string, logger: RollupLogger) => Promise<Result["plugins"]>;
-type OptionType<T, TDefine extends T | boolean | undefined> = T | TDefine | false;
-
-declare const resolve: (ids: string[], userOptions: ResolveOptions) => string;
-interface ResolveOptions extends NapiResolveOptions {
-    baseDirs?: string[];
-    caller?: string;
-}
-
-declare const safeId: (id: string, ...salt: string[]) => string;
-
-declare class MapModifier {
-    private readonly map?;
-    constructor(map?: RawSourceMap | string);
-    modify(f: (m: RawSourceMap) => void): this;
-    modifySources(op: (source: string) => string): this;
-    resolve(directory?: string): this;
-    relative(directory?: string): this;
-    toObject(): RawSourceMap | undefined;
-    toString(): string | undefined;
-    toConsumer(): SourceMapConsumer | undefined;
-    toCommentData(): string;
-    toCommentFile(fileName: string): string;
-}
-declare const getMap: (code: string, id?: string) => Promise<string | undefined>;
-declare const stripMap: (code: string) => string;
-declare const mm: (map?: RawSourceMap | string) => MapModifier;
-
-declare const hasModuleSpecifier: (url: string) => boolean;
-declare const getUrlOfPartial: (url: string) => string;
-declare const normalizeUrl: (url: string) => string;
-
-export { arrayFmt, concat, ensurePCSSOption, ensurePCSSPlugins, getMap, getUrlOfPartial, hasModuleSpecifier, inferHandlerOption, inferModeOption, inferOption, inferSourceMapOption, loadModule, mm, normalizeUrl, resolve, safeId, stripMap };
-export type { ResolveOptions };
+export { default as arrayFmt } from "./array-fmt.d.ts";
+export { default as concat } from "./concat.d.ts";
+export { default as loadModule } from "./load-module.d.ts";
+export { ensurePCSSOption, ensurePCSSPlugins, inferHandlerOption, inferModeOption, inferOption, inferSourceMapOption } from "./options.d.ts";
+export type { ResolveOptions } from "./resolve.d.ts";
+export { resolve } from "./resolve.d.ts";
+export { default as safeId } from "./safe-id.d.ts";
+export { getMap, mm, stripMap } from "./sourcemap.d.ts";
+export { getUrlOfPartial, hasModuleSpecifier, normalizeUrl } from "./url.d.ts";

package/dist/utils/index.js

@@ -0,0 +1 @@
+import{default as o}from"../packem_shared/arrayFmt-Dek5cB7m.js";import{default as t}from"../packem_shared/concat-WcWAYbOc.js";import{default as p}from"../packem_shared/loadModule-D20jQQNu.js";import{ensurePCSSOption as n,ensurePCSSPlugins as s,inferHandlerOption as l,inferModeOption as m,inferOption as d,inferSourceMapOption as u}from"../packem_shared/inferModeOption-9h3Eq6JH.js";import{resolve as M}from"../packem_shared/resolve-anj9ucIq.js";import{default as S}from"../packem_shared/safeId-BN5akJYJ.js";import{g,m as P,s as C}from"../packem_shared/sourcemap-CB6ochh0.js";import{getUrlOfPartial as h,hasModuleSpecifier as v,normalizeUrl as y}from"../packem_shared/hasModuleSpecifier-DIZeev_W.js";export{o as arrayFmt,t as concat,n as ensurePCSSOption,s as ensurePCSSPlugins,g as getMap,h as getUrlOfPartial,v as hasModuleSpecifier,l as inferHandlerOption,m as inferModeOption,d as inferOption,u as inferSourceMapOption,p as loadModule,P as mm,y as normalizeUrl,M as resolve,S as safeId,C as stripMap};

package/dist/utils/load-module.d.ts

@@ -0,0 +1,3 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+declare const loadModule: (moduleId: string, cwd: string, logger: RollupLogger) => Promise<any>;
+export default loadModule;

package/dist/utils/options.d.ts

@@ -0,0 +1,155 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { Result } from "postcss-load-config";
+import type { LoaderContext } from "../loaders/types.d.ts";
+import type { InternalStyleOptions, PostCSSOptions, StyleOptions } from "../types.d.ts";
+/**
+ * Internal mode configuration for style processing.
+ *
+ * Represents the resolved mode options that determine how CSS is handled:
+ * - emit: Output raw CSS for further processing
+ * - extract: Extract CSS to separate files
+ * - inject: Inject CSS into JavaScript at runtime
+ */
+interface Mode {
+    /** Whether to emit raw CSS for further processing */
+    emit: InternalStyleOptions["emit"];
+    /** Whether to extract CSS to separate files (boolean or filename) */
+    extract: InternalStyleOptions["extract"];
+    /** Whether to inject CSS at runtime (boolean or injection options) */
+    inject: InternalStyleOptions["inject"];
+    /** Whether to inline CSS as strings in JavaScript */
+    inline: InternalStyleOptions["inline"];
+}
+/** PostCSS option types for error messages */
+type PCSSOption = "parser" | "plugin" | "stringifier" | "syntax";
+/**
+ * Infers and validates the CSS processing mode from user options.
+ *
+ * Converts the user-provided mode configuration into internal mode settings.
+ * Supports both simple string modes and tuple modes with additional options.
+ * @param mode User-provided mode configuration
+ * @returns Resolved mode configuration object
+ * @throws Error if an invalid mode is provided
+ * @example
+ * ```typescript
+ * // Simple mode
+ * inferModeOption('extract') // { emit: false, extract: true, inject: false }
+ *
+ * // Mode with options
+ * inferModeOption(['inject', { singleTag: true }])
+ * // { emit: false, extract: false, inject: { singleTag: true } }
+ *
+ * // Default mode (inject)
+ * inferModeOption(undefined) // { emit: false, extract: false, inject: true }
+ * ```
+ */
+export declare const inferModeOption: (mode: StyleOptions["mode"]) => Mode;
+/**
+ * Infers option values from boolean or object configurations.
+ *
+ * This utility handles the common pattern where options can be:
+ * - `true`: Enable with default settings (returns empty object)
+ * - `false`: Disable the option (returns false)
+ * - `object`: Use the provided configuration
+ * - `undefined`: Use the provided default value
+ * @param option The option value to process
+ * @param defaultValue Default value when option is undefined
+ * @returns Processed option value
+ * @example
+ * ```typescript
+ * inferOption(true, {}) // {}
+ * inferOption(false, {}) // false
+ * inferOption({ custom: 'value' }, {}) // { custom: 'value' }
+ * inferOption(undefined, { default: true }) // { default: true }
+ * ```
+ */
+export declare const inferOption: <T, TDefine extends T | boolean | undefined>(option: T | boolean | undefined, defaultValue: TDefine) => OptionType<T, TDefine>;
+/**
+ * Infers source map configuration from user options.
+ *
+ * Processes source map options which can be specified as:
+ * - `boolean`: Enable/disable with default settings
+ * - `"inline"`: Enable with inline source maps
+ * - `[boolean | "inline", SourceMapOptions]`: Enable with custom options
+ * @param sourceMap User-provided source map configuration
+ * @returns Processed source map configuration for loaders
+ * @example
+ * ```typescript
+ * inferSourceMapOption(true) // { content: true, inline: false }
+ * inferSourceMapOption('inline') // { content: true, inline: true }
+ * inferSourceMapOption([true, { transform: fn }]) // { content: true, inline: false, transform: fn }
+ * inferSourceMapOption(false) // false
+ * ```
+ */
+export declare const inferSourceMapOption: (sourceMap: StyleOptions["sourceMap"]) => LoaderContext["sourceMap"];
+/**
+ * Infers handler options that support alias configuration.
+ *
+ * Processes options for handlers (like import/url resolvers) that can use aliases.
+ * If aliases are provided and the option doesn't already have aliases, they are merged.
+ * @param option Handler option configuration
+ * @param alias Path aliases to merge if not already present
+ * @returns Processed handler option with aliases
+ * @example
+ * ```typescript
+ * const aliases = { '@': '/src' };
+ *
+ * inferHandlerOption(true, aliases) // { alias: { '@': '/src' } }
+ * inferHandlerOption({ custom: true }, aliases) // { custom: true, alias: { '@': '/src' } }
+ * inferHandlerOption({ alias: { '~': '/lib' } }, aliases) // { alias: { '~': '/lib' } }
+ * ```
+ */
+export declare const inferHandlerOption: <T extends {
+    alias?: Record<string, string>;
+}>(option: T | boolean | undefined, alias: T["alias"]) => T | false;
+/**
+ * Ensures a PostCSS option is properly loaded and resolved.
+ *
+ * PostCSS options can be specified as strings (module names) or objects.
+ * This function loads string-based options as modules and validates they exist.
+ * @param option PostCSS option (string module name or object)
+ * @param type Type of PostCSS option for error messages
+ * @param cwd Current working directory for module resolution
+ * @param logger Optional logger for warnings
+ * @returns Promise resolving to the loaded PostCSS option
+ * @throws Error if string module cannot be loaded
+ * @example
+ * ```typescript
+ * // Load parser module
+ * await ensurePCSSOption('sugarss', 'parser', process.cwd()) // Loaded sugarss module
+ *
+ * // Pass through object
+ * await ensurePCSSOption(parserObject, 'parser', process.cwd()) // parserObject
+ * ```
+ */
+export declare const ensurePCSSOption: <T>(option: T | string, type: PCSSOption, cwd: string, logger: RollupLogger) => Promise<T>;
+/**
+ * Ensures PostCSS plugins are properly loaded and configured.
+ *
+ * PostCSS plugins can be specified in various formats:
+ * - String module names
+ * - Plugin objects
+ * - Arrays of [plugin, options]
+ * - Mixed arrays of the above
+ *
+ * This function normalizes all formats and loads string-based plugins as modules.
+ * @param plugins PostCSS plugins configuration
+ * @param cwd Current working directory for module resolution
+ * @param logger Optional logger for warnings
+ * @returns Promise resolving to array of loaded PostCSS plugins
+ * @example
+ * ```typescript
+ * // Load plugins from various formats
+ * await ensurePCSSPlugins([
+ *   'autoprefixer',                    // String module name
+ *   ['cssnano', { preset: 'default' }], // Plugin with options
+ *   pluginObject                       // Direct plugin object
+ * ], process.cwd())
+ * ```
+ */
+export declare const ensurePCSSPlugins: (plugins: PostCSSOptions["plugins"], cwd: string, logger: RollupLogger) => Promise<Result["plugins"]>;
+/**
+ * Type alias for option function return types
+ */
+export type OptionType<T, TDefine extends T | boolean | undefined> = T | TDefine | false;
+export {};

package/dist/utils/resolve.d.ts

@@ -0,0 +1,35 @@
+import type { NapiResolveOptions } from "oxc-resolver";
+/**
+ * Resolves module identifiers using advanced resolution strategies.
+ *
+ * This function implements sophisticated module resolution logic using the OXC resolver,
+ * supporting various resolution strategies and providing detailed error reporting.
+ * It's primarily used for resolving CSS imports, PostCSS plugins, and other dependencies.
+ *
+ * Features:
+ * - Multiple base directory support
+ * - Configurable file extensions
+ * - Symlink resolution
+ * - Detailed error reporting and debugging
+ * - Fallback resolution strategies
+ * @param ids Array of module identifiers to resolve
+ * @param userOptions Resolution configuration options
+ * @returns Absolute path to the resolved module
+ * @throws Error if no module can be resolved
+ * @example
+ * ```typescript
+ * // Resolving a PostCSS plugin
+ * const pluginPath = resolve(['autoprefixer'], {
+ *   caller: 'PostCSS',
+ *   baseDirs: ['/project/node_modules'],
+ *   extensions: ['.js', '.mjs']
+ * });
+ * ```
+ */
+export declare const resolve: (ids: string[], userOptions: ResolveOptions) => string;
+export interface ResolveOptions extends NapiResolveOptions {
+    /** directories to begin resolving from (defaults to `[__dirname]`) */
+    baseDirs?: string[];
+    /** name of the caller for error message (default to `Resolver`) */
+    caller?: string;
+}

package/dist/utils/safe-id.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generates a safe, unique JavaScript identifier from an input string.
+ *
+ * Creates a legal JavaScript identifier by:
+ * 1. Combining the input ID with a salt and additional salt parameters
+ * 2. Generating a hash of the combined string
+ * 3. Appending the hash to the ID to ensure uniqueness
+ * 4. Making the result a legal JavaScript identifier
+ *
+ * This is useful for generating variable names that won't conflict with
+ * reserved words or other identifiers in the generated code.
+ * @param id Base identifier string
+ * @param salt Additional salt values for uniqueness
+ * @returns Legal JavaScript identifier with hash suffix
+ * @example
+ * ```typescript
+ * safeId('myVar') // "myVar_a1b2c3d4"
+ * safeId('class', 'module') // "class_e5f6g7h8"
+ * safeId('my-component', 'css') // "my_component_i9j0k1l2"
+ * ```
+ */
+declare const safeId: (id: string, ...salt: string[]) => string;
+export default safeId;

package/dist/utils/sourcemap.d.ts

@@ -0,0 +1,42 @@
+import type { RawSourceMap } from "source-map-js";
+import { SourceMapConsumer } from "source-map-js";
+declare class MapModifier {
+    private readonly map?;
+    constructor(map?: RawSourceMap | string);
+    modify(f: (m: RawSourceMap) => void): this;
+    modifySources(op: (source: string) => string): this;
+    resolve(directory?: string): this;
+    relative(directory?: string): this;
+    toObject(): RawSourceMap | undefined;
+    toString(): string | undefined;
+    toConsumer(): SourceMapConsumer | undefined;
+    toCommentData(): string;
+    toCommentFile(fileName: string): string;
+}
+export declare const getMap: (code: string, id?: string) => Promise<string | undefined>;
+export declare const stripMap: (code: string) => string;
+/**
+ * Creates a MapModifier instance for source map manipulation.
+ *
+ * This utility function provides a convenient way to create MapModifier instances
+ * for working with source maps in CSS processing pipelines. The MapModifier class
+ * offers comprehensive source map manipulation capabilities including:
+ * - Path resolution and relativization
+ * - Source map merging and modification
+ * - Format conversion (object, string, consumer)
+ * - Comment generation for inline or external maps
+ * @param map Source map input (raw object or JSON string)
+ * @returns MapModifier instance for source map operations
+ * @example
+ * ```typescript
+ * // Working with source map objects
+ * const modifier = mm(rawSourceMap);
+ * modifier.resolve('/project/src').relative('/project');
+ *
+ * // Converting to different formats
+ * const mapString = modifier.toString();
+ * const consumer = modifier.toConsumer();
+ * ```
+ */
+export declare const mm: (map?: RawSourceMap | string) => MapModifier;
+export {};

package/dist/utils/url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the URL starts with a tilde followed by a digit, '@', or a letter (case-insensitive)
+ * @param url
+ * @returns
+ */
+export declare const hasModuleSpecifier: (url: string) => boolean;
+export declare const getUrlOfPartial: (url: string) => string;
+export declare const normalizeUrl: (url: string) => string;