esm-styles 0.2.8 → 0.3.1

package/dist/lib/utils/obj2css.js

@@ -1,79 +0,0 @@
-/**
- * Utilities for converting JavaScript objects to CSS strings
- */
-/**
- * Converts a CSS object to a string representation
- * @param cssObject - Object with CSS selectors and properties
- * @returns CSS string
- */
-export function obj2css(cssObject) {
-    // Convert object to JSON string with indentation
-    const json = JSON.stringify(cssObject, null, 2);
-    // Process the JSON string to convert to valid CSS
-    const css = json
-        // Replace double quotes with single quotes for strings
-        .replace(/\\"/g, "'")
-        // Convert object keys to CSS selectors
-        .replace(/"([^"]+)":\s*{/g, '$1 {')
-        // Remove commas between rule sets and add empty line
-        .replace(/},/g, '}')
-        // Remove remaining double quotes
-        .replace(/"/g, '')
-        // Restore quotes for inlined URLs
-        .replace(/url\('(.+)'\)/g, 'url("$1")')
-        // Convert property-value commas to semicolons
-        .replace(/,(\s*})/g, ';$1')
-        // Remove the outermost curly braces
-        .replace(/^{|}$/g, '')
-        // Convert commas between property values to semicolons
-        .replace(/,\s*(?=[a-z-]+:)/g, ';\n  ')
-        // Remove indentation from the start of lines
-        .replace(/^( {2})/gm, '')
-        // Add semicolons before closing brackets if missing
-        .replace(/([^;])\s*}/g, '$1;\n}')
-        // Ensure space between property name and value
-        .replace(/:\s*/g, ': ')
-        // Clean up extra spaces
-        .replace(/\s+/g, ' ')
-        // Fix colon spacing in selectors
-        .replace(/([:#]) /g, '$1');
-    // Split into lines for additional processing
-    const lines = css.split('\n');
-    const result = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // Handle property lines
-        if (line.includes(': ')) {
-            result.push('  ' + line.trim());
-        }
-        // Handle selector lines
-        else if (line.includes('{')) {
-            result.push(line.trim());
-        }
-        // Handle closing bracket lines
-        else if (line.includes('}')) {
-            result.push('}');
-        }
-        // Other lines
-        else {
-            result.push(line);
-        }
-    }
-    return result.join('\n');
-}
-/**
- * Prettifies a CSS string by ensuring consistent spacing and formatting
- * @param cssString - CSS string to prettify
- * @returns Prettified CSS string
- */
-export function prettifyCss(cssString) {
-    return (cssString
-        // Ensure consistent newlines between rule sets
-        .replace(/}\s*/g, '}\n\n')
-        // Fix spacing inside brackets
-        .replace(/{\s*/g, ' {\n')
-        // Clean up extra newlines
-        .replace(/\n{3,}/g, '\n\n')
-        // Trim the string
-        .trim());
-}

package/dist/lib/utils/selectors.d.ts

@@ -1,15 +0,0 @@
-/**
- * Utilities for working with CSS selectors
- */
-/**
- * Joins selector parts into a valid CSS selector
- * @param path - Array of selector parts or a single selector
- * @returns Combined CSS selector
- */
-export declare function joinSelectors(path: string | string[]): string;
-/**
- * Creates a Cartesian product of selector parts and joins them
- * @param parts - Array of selector parts arrays
- * @returns Array of all possible combined selectors
- */
-export declare function cartesianSelectors(parts: string[][]): string[];

package/dist/lib/utils/selectors.js

@@ -1,87 +0,0 @@
-/**
- * Utilities for working with CSS selectors
- */
-import { isHtmlTag } from './tags.js';
-/**
- * Joins selector parts into a valid CSS selector
- * @param path - Array of selector parts or a single selector
- * @returns Combined CSS selector
- */
-export function joinSelectors(path) {
-    const array = typeof path === 'string' ? [path] : path;
-    let result = '';
-    for (const keyStr of array) {
-        // Skip empty key strings
-        if (!keyStr.trim())
-            continue;
-        const key = keyStr.replace(/&/g, '').trim();
-        if (isHtmlTag(key)) {
-            // If it's an HTML tag, just add it with a space
-            result += ` ${key}`;
-        }
-        else {
-            let prefix = '';
-            let selector = key;
-            // Handle reference to parent selector with &
-            if (/^&/.test(keyStr)) {
-                prefix += ' ';
-            }
-            // Handle double underscore for descendant of any level (T6)
-            if (/^__/.test(key)) {
-                prefix += ' ';
-                selector = selector.replace(/^__/, '');
-            }
-            // Handle single underscore for class selector (T5)
-            if (/^_/.test(key)) {
-                selector = selector.replace(/^_/, '');
-                if (!isHtmlTag(selector)) {
-                    // If not a tag, increase level
-                    prefix += ' ';
-                }
-            }
-            // Add dot for class selectors if needed
-            if (!/^[.:#*[~+>]/.test(selector)) {
-                if (!/\./.test(prefix))
-                    prefix += '.';
-            }
-            // Special handling for universal selector
-            if (/^\*/.test(selector)) {
-                prefix = ' ' + prefix;
-            }
-            result += prefix + selector;
-        }
-    }
-    // Fix any double dots that might have been created
-    result = result.replace(/\.\s*\./g, '.');
-    // Clean up whitespace
-    result = result
-        // Remove extra spaces
-        .replace(/\s+/g, ' ')
-        // Preserve proper spacing around combinators
-        .replace(/\s*([>+~])\s*/g, ' $1 ')
-        // Fix pseudo-classes and pseudo-elements
-        .replace(/\s+:/g, ':')
-        // Fix attribute selectors
-        .replace(/\s+\[/g, '[')
-        // Trim whitespace
-        .trim();
-    return result;
-}
-/**
- * Creates a Cartesian product of selector parts and joins them
- * @param parts - Array of selector parts arrays
- * @returns Array of all possible combined selectors
- */
-export function cartesianSelectors(parts) {
-    // Base case: If empty or just one part, return it flattened
-    if (parts.length === 0)
-        return [];
-    if (parts.length === 1)
-        return parts[0];
-    // Implementation of cartesian product
-    const result = parts.reduce((acc, curr) => acc.flatMap((x) => curr.map((y) => [...x, y])), [[]]);
-    return result.map((selectors) => {
-        // Handle comma-separated selectors by creating real CSS selector lists
-        return joinSelectors(selectors.filter(Boolean));
-    });
-}

package/dist/lib/utils/tags.d.ts

@@ -1,10 +0,0 @@
-/**
- * List of all HTML tags used to identify selectors
- */
-export declare const htmlTags: string[];
-/**
- * Checks if a string is an HTML tag name
- * @param key - String to check
- * @returns True if the string is an HTML tag name
- */
-export declare function isHtmlTag(key: string): boolean;

package/dist/lib/utils/tags.js

@@ -1,128 +0,0 @@
-/**
- * List of all HTML tags used to identify selectors
- */
-export const htmlTags = [
-    'a',
-    'abbr',
-    'address',
-    'area',
-    'article',
-    'aside',
-    'audio',
-    'b',
-    'base',
-    'bdi',
-    'bdo',
-    'blockquote',
-    'body',
-    'br',
-    'button',
-    'canvas',
-    'caption',
-    'cite',
-    'code',
-    'col',
-    'colgroup',
-    'data',
-    'datalist',
-    'dd',
-    'del',
-    'details',
-    'dfn',
-    'dialog',
-    'div',
-    'dl',
-    'dt',
-    'em',
-    'embed',
-    'fieldset',
-    'figcaption',
-    'figure',
-    'footer',
-    'form',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'head',
-    'header',
-    'hgroup',
-    'hr',
-    'html',
-    'i',
-    'iframe',
-    'img',
-    'input',
-    'ins',
-    'kbd',
-    'label',
-    'legend',
-    'li',
-    'link',
-    'main',
-    'map',
-    'mark',
-    'meta',
-    'meter',
-    'nav',
-    'noscript',
-    'object',
-    'ol',
-    'optgroup',
-    'option',
-    'output',
-    'p',
-    'param',
-    'picture',
-    'pre',
-    'progress',
-    'q',
-    'rp',
-    'rt',
-    'ruby',
-    's',
-    'samp',
-    'script',
-    'section',
-    'select',
-    'slot',
-    'small',
-    'source',
-    'span',
-    'strong',
-    'style',
-    'sub',
-    'summary',
-    'sup',
-    'svg',
-    'table',
-    'tbody',
-    'td',
-    'template',
-    'textarea',
-    'tfoot',
-    'th',
-    'thead',
-    'time',
-    'title',
-    'tr',
-    'track',
-    'u',
-    'ul',
-    'var',
-    'video',
-    'wbr',
-];
-/**
- * Checks if a string is an HTML tag name
- * @param key - String to check
- * @returns True if the string is an HTML tag name
- */
-export function isHtmlTag(key) {
-    if (/^\w+[.#:[~+ ]/.test(key)) {
-        return htmlTags.includes(key.split(/[.#:[~+ ]/)[0]);
-    }
-    return htmlTags.includes(key);
-}

package/dist/lib/utils/traversal.d.ts

@@ -1,25 +0,0 @@
-/**
- * Utility for traversing and transforming nested objects
- */
-/**
- * Type for node visitor functions
- */
-export type NodeVisitor<T> = (node: any, path: string, root: any, index: number) => T;
-/**
- * Traverses a nested object and applies a visitor function to each node
- * @param node - The object to traverse
- * @param visitor - Function to call for each node
- * @param path - Current path in the object (for tracking)
- * @param root - Root object (for reference)
- * @param index - Current index in array (if applicable)
- * @param separator - Path separator character
- * @returns The result of the visitor function on the current node
- */
-export declare function traverseObject<T>(node: any, visitor: NodeVisitor<T>, path?: string, root?: any, index?: number, separator?: string): T;
-/**
- * Determines the type of a node in the CSS object
- * @param node - The node to check
- * @param path - Current path in the object
- * @returns The identified node type as a string
- */
-export declare function determineNodeType(node: any, path?: string): string;

package/dist/lib/utils/traversal.js

@@ -1,78 +0,0 @@
-/**
- * Utility for traversing and transforming nested objects
- */
-/**
- * Traverses a nested object and applies a visitor function to each node
- * @param node - The object to traverse
- * @param visitor - Function to call for each node
- * @param path - Current path in the object (for tracking)
- * @param root - Root object (for reference)
- * @param index - Current index in array (if applicable)
- * @param separator - Path separator character
- * @returns The result of the visitor function on the current node
- */
-export function traverseObject(node, visitor, path = '', root, index = -1, separator = '\\') {
-    const realRoot = root || node;
-    // Handle arrays
-    if (Array.isArray(node)) {
-        const processedItems = node.map((item, idx) => traverseObject(item, visitor, path, realRoot, idx, separator));
-        return visitor(processedItems, path, realRoot, index);
-    }
-    // Handle objects (but not null)
-    if (node !== null && typeof node === 'object') {
-        const processedObject = Object.keys(node).reduce((result, key) => {
-            const newPath = path ? `${path}${separator}${key}` : key;
-            const processedValue = traverseObject(node[key], visitor, newPath, realRoot, index, separator);
-            result[key] = processedValue;
-            return result;
-        }, {});
-        return visitor(processedObject, path, realRoot, index);
-    }
-    // Handle primitive values
-    return visitor(node, path, realRoot, index);
-}
-/**
- * Determines the type of a node in the CSS object
- * @param node - The node to check
- * @param path - Current path in the object
- * @returns The identified node type as a string
- */
-export function determineNodeType(node, path) {
-    if (!path)
-        return 'unknown';
-    const lastKey = path.split('\\').pop() || '';
-    // Layer statement
-    if (/^@layer/.test(lastKey) && typeof node === 'string') {
-        return 'layer statement';
-    }
-    // Layer block
-    if (/^@layer/.test(lastKey) && typeof node === 'object' && node !== null) {
-        return 'layer block';
-    }
-    // Container query
-    if (/^@container/.test(lastKey) &&
-        typeof node === 'object' &&
-        node !== null) {
-        return 'container query block';
-    }
-    // Media query or prefix
-    if (/^@/.test(lastKey)) {
-        return 'media query or prefix';
-    }
-    // CSS property-value pair (end value)
-    if (isPrimitiveValue(node)) {
-        return 'selector';
-    }
-    return 'unknown';
-}
-/**
- * Checks if a value is a primitive that can be used as a CSS property value
- * @param value - Value to check
- * @returns True if the value is a primitive
- */
-function isPrimitiveValue(value) {
-    return (value === null ||
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean');
-}

package/dist/watch.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'child_process'
-import path from 'path'
-import process from 'process'
-
-const configPath = process.argv[2] || 'esm-styles.config.js'
-const configModule = await import(
-  path.isAbsolute(configPath)
-    ? configPath
-    : path.resolve(process.cwd(), configPath)
-)
-const config = configModule.default
-
-const basePath = path.resolve(process.cwd(), config.basePath || '.')
-const sourcePath = path.join(basePath, config.sourcePath || '')
-
-const buildJsPath = path.resolve(
-  path.dirname(new URL(import.meta.url).pathname),
-  'build.js'
-)
-
-const nodemonArgs = [
-  '--watch',
-  sourcePath,
-  '--ext',
-  'mjs',
-  '--ignore',
-  path.join(sourcePath, '$*.mjs'),
-  '--exec',
-  `node ${buildJsPath} ${configPath}`,
-]
-
-console.log('[esm-styles] Running:', 'nodemon', ...nodemonArgs)
-
-const nodemon = spawn('nodemon', nodemonArgs, { stdio: 'inherit' })
-
-nodemon.on('exit', (code) => process.exit(code))