beathers 5.2.2 → 5.3.0

package/dist/scripts/commands/fonts.js

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+import { findConfigFile, loadConfig, promptInput, promptSelection, promptUser, saveConfig } from '@commands';
+import { importedFont, localFont } from '@data';
+export async function AddFont() {
+    const configFile = await findConfigFile();
+    if (!configFile) {
+        console.error('❌ No config file found. Run "\x1b[34mbeathers init\x1b[0m" first.');
+        return;
+    }
+    const question = (q, locale) => {
+        const lang = locale.toUpperCase();
+        const questions = {
+            title: `\x1b[36m📝 Enter "${lang} variant" title:\x1b[0m `,
+            unicode: `\x1b[36m🔤 Enter "${lang} variant" unicode range (optional):\x1b[0m `,
+            isLocal: `\x1b[33m🔤 Is "${lang} variant" a local font?\x1b[0m\n\x1b[32m[Y]\x1b[0m Yes \x1b[31m[N]\x1b[0m No: `,
+            url: `\x1b[36m🌐 Enter "${lang} variant" URL (must start with http:// or https://):\x1b[0m `,
+            format: `\x1b[36m📄 Choose "${lang} variant" format:\x1b[0m`,
+        };
+        return questions[q];
+    };
+    try {
+        const fontName = await promptInput('\x1b[36m📝 Enter font name:\x1b[0m ');
+        if (!fontName) {
+            console.error('❌ Font name is \x1b[31mrequired\x1b[0m.');
+            return;
+        }
+        const weightsInput = await promptInput('\x1b[36m⚖️ Enter font weights (comma-separated, e.g., light,regular,bold) (optional):\x1b[0m ');
+        const weights = weightsInput?.split(',').map((w) => w.trim());
+        const stylesInput = await promptInput('\x1b[36m🎨 Enter font styles (comma-separated, e.g., normal,italic) (optional):\x1b[0m ');
+        const styles = stylesInput?.split(',').map((s) => s.trim());
+        const localesInput = await promptInput('\x1b[36m🌐 Enter font variant locales (comma-separated, e.g., en,ar):\x1b[0m ');
+        const locales = localesInput?.split(',').map((w) => w.trim());
+        const variants = {};
+        for (const l of locales) {
+            let url, format;
+            const title = await promptInput(question('title', l));
+            const unicode = await promptInput(question('unicode', l));
+            const isLocal = await promptUser(question('isLocal', l));
+            if (!isLocal)
+                while (true) {
+                    url = await promptInput(question('url', l));
+                    if (url && /^https?:\/\//.test(url))
+                        break;
+                    console.error('❌ Invalid URL format. URL must start with \x1b[36mhttp://\x1b[0m or \x1b[36mhttps://\x1b[0m');
+                }
+            else
+                format = await promptSelection(question('format', l), ['woff2', 'woff']);
+            variants[l] = {
+                title: title ?? fontName,
+                ...(unicode && { unicode }),
+                ...(format && { format }),
+                ...(isLocal === false && { isLocal }),
+                ...(!isLocal && url && { url: url }),
+            };
+        }
+        const font = {
+            ...(weights.length > 0 && {
+                weights: weights.filter((w) => ['thin', 'extra-light', 'light', 'regular', 'medium', 'semibold', 'bold', 'extra-bold', 'black'].includes(w)),
+            }),
+            ...(styles.length > 0 && {
+                styles: styles.filter((s) => ['normal', 'italic', 'oblique'].includes(s)),
+            }),
+            variants,
+        };
+        const config = await loadConfig(configFile);
+        config.typography ??= {};
+        config.typography.fonts ??= {};
+        config.typography.fonts[fontName] = font;
+        await saveConfig(configFile, config);
+        console.log(`✅ Successfully added font \x1b[32m"${fontName}"\x1b[0m!`);
+    }
+    catch (error) {
+        console.error('❌ Error adding font:', error);
+    }
+}
+export async function RemoveFont() {
+    const configFile = await findConfigFile();
+    if (!configFile) {
+        console.error('❌ No config file found. Run "\x1b[34mbeathers init\x1b[0m" first.');
+        return;
+    }
+    const fontName = await promptInput('\x1b[36m🗑️ Enter font name to remove:\x1b[0m\n\x1b[33mThis will delete all weights, styles, and variants of the selected font.\x1b[0m\n> ');
+    if (!fontName) {
+        console.error('❌ Font name is \x1b[31mrequired\x1b[0m.');
+        return;
+    }
+    try {
+        const config = await loadConfig(configFile);
+        if (!config.typography?.fonts?.[fontName]) {
+            console.error(`❌ Font "\x1b[31m${fontName}\x1b[0m" not found in config.`);
+            return;
+        }
+        delete config.typography.fonts[fontName];
+        await saveConfig(configFile, config);
+        console.log(`✅ Successfully removed font \x1b[32m"${fontName}"\x1b[0m!`);
+    }
+    catch (error) {
+        console.error('❌ Error removing font:', error);
+    }
+}
+export async function ImportFont() {
+    const configFile = await findConfigFile();
+    if (!configFile) {
+        console.error('❌ No config file found. Run "\x1b[34mbeathers init\x1b[0m" first.');
+        return;
+    }
+    const isLocal = await promptUser('\x1b[33m🔤 Do you want a local font?\x1b[0m\n\x1b[32m[Y]\x1b[0m Yes \x1b[31m[N]\x1b[0m No: ');
+    const fontName = await promptInput('\x1b[36m📝 Enter font name:\x1b[0m ');
+    if (!fontName) {
+        console.error('❌ Font name is \x1b[31mrequired\x1b[0m.');
+        return;
+    }
+    try {
+        const config = await loadConfig(configFile);
+        config.typography ??= {};
+        config.typography.fonts ??= {};
+        config.typography.fonts[fontName] = isLocal ? localFont : importedFont;
+        await saveConfig(configFile, config);
+        console.log(`✅ Successfully imported sample font \x1b[32m"${fontName}"\x1b[0m!`);
+    }
+    catch (error) {
+        console.error('❌ Error importing font sample:', error);
+    }
+}

package/dist/scripts/commands/help.d.ts

@@ -0,0 +1 @@
+export declare function Help(): void;

package/dist/scripts/commands/help.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+const commands = [
+    { cmd: '--help', description: 'Show available commands' },
+    { cmd: '-v', description: 'Show beathers version' },
+    { divider: true },
+    { cmd: 'init', description: 'Initialize beathers configuration file' },
+    { cmd: 'build', description: 'Build theme from configuration file' },
+    { divider: true },
+    { cmd: 'add-font', description: 'Add a new font to the configuration file' },
+    { cmd: 'remove-font', description: 'Remove a font from the configuration file' },
+    { cmd: 'import-font-sample', description: 'Import sample font to configuration file' },
+    { divider: true },
+    { cmd: 'add-colors', description: 'Add a new colors to the configuration file' },
+    { cmd: 'remove-color', description: 'Remove a color from configuration file' },
+    { cmd: 'import-color-pack', description: 'Import a color pack to configuration file' },
+    { cmd: 'import-color', description: 'Import a specific color to configuration file' },
+];
+export function Help() {
+    console.log('\n🎨 Beathers CLI - Design System Builder\n');
+    const table = [
+        ['Command', 'Description', 'Examples'],
+        ['-------', '-----------', '--------'],
+    ];
+    commands.forEach(({ cmd, description, divider }) => {
+        const example = `npx beathers ${cmd}`;
+        if (cmd && description)
+            table.push([cmd, description, example]);
+        if (cmd === '-v')
+            table.push(['', '', 'npx beathers --version']);
+        if (divider)
+            table.push(['', '', '']);
+    });
+    const maxLengths = table[0].map((_, colIndex) => Math.max(...table.map((row) => row[colIndex].length)));
+    table.forEach((row) => {
+        const formattedRow = row.map((cell, colIndex) => cell.padEnd(maxLengths[colIndex])).join('  ');
+        console.log(formattedRow);
+    });
+    console.log('\nFlags:');
+    console.log("  --local               Build with user's custom output path (use with build command)");
+    console.log('                        Example: npx beathers build --local');
+    console.log();
+}

package/dist/scripts/commands/index.d.ts

@@ -0,0 +1,13 @@
+import { Theme } from '@types';
+export declare function promptUser(question: string): Promise<boolean>;
+export declare function promptInput(question: string): Promise<string>;
+export declare function promptSelection<T extends string>(question: string, options: T[]): Promise<T>;
+export declare function findConfigFile(): Promise<string | null>;
+export declare function loadConfig(filePath: string): Promise<Theme>;
+export declare function saveConfig(filePath: string, config: Theme): Promise<void>;
+export * from './build.js';
+export * from './colors.js';
+export * from './fonts.js';
+export * from './help.js';
+export * from './init.js';
+export * from './version.js';

package/dist/scripts/commands/index.js

@@ -0,0 +1,95 @@
+/* eslint-disable no-console */
+import fs from 'fs-extra';
+import path from 'path';
+// Functions
+export async function promptUser(question) {
+    const readline = await import('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase().startsWith('y'));
+        });
+    });
+}
+export async function promptInput(question) {
+    const readline = await import('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function promptSelection(question, options) {
+    const readline = await import('readline');
+    return new Promise((resolve) => {
+        const ask = () => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            console.log(question);
+            options.forEach((option, index) => console.log(`  ${index + 1}. ${option}`));
+            rl.question('Enter your choice (number): ', (answer) => {
+                rl.close();
+                const choice = parseInt(answer.trim()) - 1;
+                if (choice >= 0 && choice < options.length)
+                    resolve(options[choice]);
+                else {
+                    console.log('❌ Invalid choice. Please try again.');
+                    ask();
+                }
+            });
+        };
+        ask();
+    });
+}
+export async function findConfigFile() {
+    const userConfigFiles = ['beathers.configs.ts', 'beathers.configs.js', 'beathers.configs.json'];
+    for (const filename of userConfigFiles) {
+        const fullPath = path.join(process.cwd(), filename);
+        if (await fs.pathExists(fullPath))
+            return fullPath;
+    }
+    return null;
+}
+export async function loadConfig(filePath) {
+    const extension = path.extname(filePath);
+    if (extension === '.json') {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    else if (['.js', '.ts'].includes(extension)) {
+        let content = await fs.readFile(filePath, 'utf-8');
+        content = content.replace(/import.*from.*['"].*['"];?\n/g, '');
+        content = content.replace(/export default\s+/, '');
+        content = content.replace(/satisfies Theme\s*$/, '');
+        try {
+            const config = eval(`(${content})`);
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse config file: ${error}`);
+        }
+    }
+    throw new Error(`Unsupported config file format: ${extension}`);
+}
+export async function saveConfig(filePath, config) {
+    const extension = path.extname(filePath);
+    if (extension === '.json')
+        await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+    else if (extension === '.js') {
+        const content = `export default ${JSON.stringify(config, null, 2)}`;
+        await fs.writeFile(filePath, content);
+    }
+    else if (extension === '.ts') {
+        const content = `import type { Theme } from 'beathers'\n\nexport default ${JSON.stringify(config, null, 2)} satisfies Theme`;
+        await fs.writeFile(filePath, content);
+    }
+}
+// Commands
+export * from './build.js';
+export * from './colors.js';
+export * from './fonts.js';
+export * from './help.js';
+export * from './init.js';
+export * from './version.js';

package/dist/scripts/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function Init(): Promise<void>;

package/dist/scripts/commands/init.js

@@ -0,0 +1,129 @@
+/* eslint-disable no-console */
+import { ReadDefaultValues } from '@helpers';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'node:url';
+import path from 'path';
+import { promptSelection, promptUser } from '@commands';
+async function getDefaultValues() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const projectRoot = path.resolve(__dirname, '..', '..');
+    return (await ReadDefaultValues([
+        path.join(projectRoot, 'scss', 'settings', '_defaults.scss'),
+        path.join(projectRoot, 'scss', 'settings', '_configs.scss'),
+        path.join(projectRoot, 'scss', 'settings', '_index.scss'),
+    ], [
+        'colors',
+        'fonts',
+        'fontMainPath',
+        'fontFormat',
+        'fontWeights',
+        'fontStyles',
+        'textTruncate',
+        'defaultFontFamilies',
+        'fontSizes',
+        'axisDivisions',
+        'breakpoints',
+        'wrappers',
+        'opacities',
+        'blurValues',
+        'insetValues',
+        'guttersValues',
+        'bordersValue',
+        'radiuses',
+        'useMediaQueries',
+        'useIcons',
+        'useFontFamilies',
+        'useFontSizes',
+        'useFontShapes',
+        'useTextAligns',
+        'useTextTruncate',
+        'useColors',
+        'useColorsOpacities',
+        'useColorsLightMode',
+        'useColorsDarkMode',
+        'useCurrentColors',
+        'useRootColors',
+        'useGrid',
+        'useFlex',
+        'useTransitions',
+        'useWrappers',
+        'useShadows',
+        'useDisplays',
+        'useOverflows',
+        'useOpacities',
+        'useBlur',
+        'useObjectFits',
+        'usePositions',
+        'useInsets',
+        'useSizes',
+        'useGutters',
+        'useBorders',
+        'useTextBorders',
+        'useRadius',
+    ]));
+}
+export async function Init() {
+    const format = await promptSelection('\x1b[36m📁 Choose config format:\x1b[0m', ['json', 'js', 'ts']);
+    const formatMap = { json: 'beathers.configs.json', js: 'beathers.configs.js', ts: 'beathers.configs.ts' };
+    const fileName = formatMap[format];
+    const filePath = path.join(process.cwd(), fileName);
+    if (await fs.pathExists(filePath)) {
+        const shouldOverride = await promptUser(`\x1b[33m⚠️  ${fileName} already exists. Do you want to override it?\x1b[0m\n\x1b[32m[Y]\x1b[0m Yes \x1b[31m[N]\x1b[0m No: `);
+        if (!shouldOverride) {
+            console.log('❌ Operation canceled.');
+            return;
+        }
+    }
+    const includeStarterValues = await promptUser('\x1b[36m📝 Would you like to include starter configuration values?\x1b[0m\n\x1b[32m[Y]\x1b[0m Yes \x1b[31m[N]\x1b[0m No: ');
+    const emptyTemplate = {
+        colors: {},
+        typography: {
+            defaultFontFamilies: [],
+            fontMainPath: '',
+            fontFormat: '',
+            fontWeights: [],
+            fontStyles: [],
+            fontSizes: {},
+            textTruncate: 0,
+            fonts: {},
+        },
+        settings: {
+            axisDivisions: 0,
+            opacities: [],
+            blurValues: [],
+            insetValues: [],
+            bordersValue: 0,
+            radiuses: [],
+            breakpoints: {},
+            wrappers: {},
+            guttersValues: {},
+        },
+        roles: {},
+    };
+    let content = '';
+    if (format === 'json') {
+        const data = includeStarterValues ? await getDefaultValues() : emptyTemplate;
+        content = JSON.stringify(data, null, 2);
+    }
+    else if (format === 'js') {
+        if (includeStarterValues) {
+            const defaultValues = await getDefaultValues();
+            content = `export default ${JSON.stringify(defaultValues, null, 2)}`;
+        }
+        else
+            content = `export default ${JSON.stringify(emptyTemplate, null, 2)}`;
+    }
+    else if (format === 'ts') {
+        const importLine = "import type { Theme } from 'beathers'\n\n";
+        if (includeStarterValues) {
+            const defaultValues = await getDefaultValues();
+            content = `${importLine}export default ${JSON.stringify(defaultValues, null, 2)} satisfies Theme`;
+        }
+        else
+            content = `${importLine}export default ${JSON.stringify(emptyTemplate, null, 2)} satisfies Theme`;
+    }
+    await fs.writeFile(filePath, content);
+    const starterText = includeStarterValues ? ' with starter values' : '';
+    console.log(`✅ Successfully created \x1b[32m${fileName}\x1b[0m${starterText}`);
+}

package/dist/scripts/commands/list.d.ts

@@ -0,0 +1,2 @@
+export declare function Commands(args: any): Record<string, () => void | Promise<void>>;
+export type CommandKey = '--help' | '-v' | '--version' | 'init' | 'build' | 'add-font' | 'remove-font' | 'import-font-sample' | 'add-colors' | 'remove-color' | 'import-color-pack' | 'import-color';

package/dist/scripts/commands/list.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import { AddColors, AddFont, Build, Help, ImportColor, ImportColorPack, ImportFont, Init, RemoveColor, RemoveFont, Version, } from '@commands';
+const commands = {
+    '--help': () => Help(),
+    '-v': () => Version(),
+    '--version': () => Version(),
+    init: async () => await Init(),
+    build: async () => await Build(),
+    '--local': async () => await Build(),
+    'add-font': async () => await AddFont(),
+    'remove-font': async () => await RemoveFont(),
+    'import-font-sample': async () => await ImportFont(),
+    'add-colors': async () => await AddColors(),
+    'remove-color': async () => await RemoveColor(),
+    'import-color-pack': async () => await ImportColorPack(),
+    'import-color': async () => await ImportColor(),
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Commands(args) {
+    const list = {
+        ...commands,
+        default: () => {
+            console.error(`❌ Command not found: "${args[0]}"`);
+            console.log('💡 Run "\x1b[34mbeathers --help\x1b[0m" to see all available commands.');
+            process.exit(1);
+        },
+    };
+    return list;
+}

package/dist/scripts/commands/version.d.ts

@@ -0,0 +1 @@
+export declare function Version(): void;

package/dist/scripts/commands/version.js

@@ -0,0 +1,13 @@
+/* eslint-disable no-console */
+import fs from 'fs-extra';
+import path from 'path';
+export function Version() {
+    const packagePath = path.join(process.cwd(), 'package.json');
+    try {
+        const packageInfo = fs.readJsonSync(packagePath);
+        console.log(`📦 \x1b[34mbeathers\x1b[0m v${packageInfo.version}`);
+    }
+    catch {
+        console.log('📦 \x1b[34mbeathers\x1b[0m CLI');
+    }
+}

package/dist/scripts/{BuildScssVariables.d.ts → helpers/BuildScssVariables.d.ts}

@@ -1,2 +1,2 @@
-import { Theme } from './types.js';
+import { Theme } from '@types';
 export declare function BuildScssVariables(theme: Theme): string;

package/dist/scripts/{BuildScssVariables.js → helpers/BuildScssVariables.js}

@@ -1,6 +1,6 @@
 export function BuildScssVariables(theme) {
     const { colors, roles, settings, typography } = theme;
-    let scss = '// Generated by BuildTheme.ts\n // Do not edit this file directly\n\n';
+    let scss = '// Generated by Beathers builder\n // Do not edit this file directly\n\n';
     if (colors) {
         scss += '\n\n// --- Colors ---\n';
         scss += '$colors: (\n';
@@ -32,8 +32,8 @@ export function BuildScssVariables(theme) {
             }
             scss += ');\n';
         }
-        if (typography?.textTruncate)
-            scss += `$textTruncate: ${typography.textTruncate};\n`;
+        if (typography?.textTruncate?.length)
+            scss += `$textTruncate: ${typography.textTruncate.join(', ')};\n`;
         if (typography?.fonts) {
             scss += '$fonts: (\n';
             for (const [name, font] of Object.entries(typography.fonts)) {
@@ -76,7 +76,7 @@ export function BuildScssVariables(theme) {
         if (settings?.insetValues)
             scss += `$insetValues: (${settings.insetValues.join(', ')});\n`;
         if (settings?.bordersValue)
-            scss += `$bordersValue: ${settings.bordersValue};\n`;
+            scss += `$bordersValue: (${settings.bordersValue.join(', ')});\n`;
         if (settings?.radiuses)
             scss += `$radiuses: (${settings.radiuses.join(', ')});\n`;
         if (settings?.breakpoints) {

package/dist/scripts/{LoadUserConfigs.d.ts → helpers/LoadUserConfigs.d.ts}

@@ -1,2 +1,2 @@
-import { Theme } from './types.js';
+import { Theme } from '@types';
 export declare function LoadUserConfigs(projectPath?: string): Promise<Theme | null>;

package/dist/scripts/{Merge.d.ts → helpers/Merge.d.ts}

@@ -1,2 +1,2 @@
-import { Theme } from './types.js';
+import { Theme } from '@types';
 export declare function DeepMerge(defaults: Partial<Theme>, configs: Partial<Theme> | null): Theme;

package/dist/scripts/{ReadDefaultValues.d.ts → helpers/ReadDefaultValues.d.ts}

@@ -1,2 +1,2 @@
-import { Theme } from './types.js';
+import { Theme } from '@types';
 export declare function ReadDefaultValues(files: string[], VariableNames: string[]): Promise<Partial<Theme>>;

package/dist/scripts/{ReadDefaultValues.js → helpers/ReadDefaultValues.js}

@@ -53,8 +53,10 @@ function buildColors(value) {
     const raw = value
         .replace(/\(/g, '{')
         .replace(/\)/g, '}')
+        .replace(/'/g, '"')
         .replace(/#([0-9a-fA-F]{3,6})/g, '"#$1"')
-        .replace(/,\s*}/g, '}');
+        .replace(/,\s*}/g, '}')
+        .replace(/\n\s*/g, '');
     const parsed = JSON.parse(raw);
     return parsed;
 }
@@ -95,14 +97,16 @@ export async function ReadDefaultValues(files, VariableNames) {
                 else if ([
                     'fontWeights',
                     'fontStyles',
+                    'textTruncate',
                     'opacities',
                     'blurValues',
                     'radiuses',
                     'defaultFontFamilies',
                     'insetValues',
+                    'bordersValue',
                 ].includes(name))
                     result = buildArray(value);
-                else if (['textTruncate', 'axisDivisions', 'bordersValue'].includes(name))
+                else if (['axisDivisions'].includes(name))
                     result = cleanNumber(value);
                 else
                     result = cleanString(value);

package/dist/scripts/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BuildScssVariables.js';
+export * from './CallNewVariables.js';
+export * from './LoadUserConfigs.js';
+export * from './Merge.js';
+export * from './ReadDefaultValues.js';

package/dist/scripts/helpers/index.js

@@ -0,0 +1,5 @@
+export * from './BuildScssVariables.js';
+export * from './CallNewVariables.js';
+export * from './LoadUserConfigs.js';
+export * from './Merge.js';
+export * from './ReadDefaultValues.js';

package/dist/scripts/types.d.ts

@@ -1,52 +1,89 @@
+/** CSS size unit values supporting px, rem, em, viewport units, and percentages */
 type SizeUnit = `${number}px` | `${number}rem` | `${number}em` | `${number}vw` | `${number}vh` | `${number}%`;
+/** Color configuration object with optional light and dark theme hex values */
 type ColorType = Record<string, {
-    light: `#${string}`;
-    dark: `#${string}`;
+    light?: `#${string}`;
+    dark?: `#${string}`;
 }>;
+/** Available font weight values from thin to black */
 type FontWeight = 'thin' | 'extra-light' | 'light' | 'regular' | 'medium' | 'semibold' | 'bold' | 'extra-bold' | 'black';
+/** Font style options for normal, italic, or oblique text */
 type FontStyle = 'normal' | 'italic' | 'oblique';
 interface FontVariant {
+    /** Display name for the font variant */
     title: string;
+    /** Unicode range for the font variant */
     unicode?: string;
+    /** Font file format. */
     format?: 'woff' | 'woff2';
+    /** Whether the font is locally installed. @default true */
     isLocal?: boolean;
+    /** Remote URL for downloading the font */
     url?: `https://${string}` | `http://${string}`;
 }
+/** Font configuration with weights, styles, and variants */
 type FontType = {
+    /** Available font weights for this font family */
     weights?: FontWeight[];
+    /** Available font styles for this font family */
     styles?: FontStyle[];
+    /** Named font variants with specific configurations */
     variants?: Record<string, FontVariant>;
 };
 interface Typography {
+    /** Default font families to use as fallbacks */
     defaultFontFamilies?: string[];
+    /** Base path for font files */
     fontMainPath?: string;
+    /** Default font format for all fonts. */
     fontFormat?: 'woff' | 'woff2';
+    /** Global font weights available across all fonts */
     fontWeights?: FontWeight[];
+    /** Global font styles available across all fonts */
     fontStyles?: FontStyle[];
+    /** Named font sizes mapped to CSS size units */
     fontSizes?: Record<string, SizeUnit>;
-    textTruncate?: number;
+    /** Line counts for text truncation utilities */
+    textTruncate?: number[];
+    /** Font family configurations */
     fonts?: Record<string, FontType>;
 }
 interface Settings {
+    /** Number of divisions for grid axis calculations. @default 12 */
     axisDivisions?: number;
+    /** Opacity values for transparency utilities (0-100 range) */
     opacities?: number[];
+    /** Blur values in pixels for filter utilities */
     blurValues?: number[];
+    /** Inset values for positioning utilities */
     insetValues?: number[];
-    bordersValue?: number;
+    /** Border width values in pixels */
+    bordersValue?: number[];
+    /** Border radius values in pixels */
     radiuses?: number[];
+    /** Responsive breakpoints for media queries */
     breakpoints?: Record<'null' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl', 0 | SizeUnit>;
+    /** Container wrapper configurations for different breakpoints */
     wrappers?: Record<'null' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl', {
         width: SizeUnit;
         padding?: SizeUnit;
     }>;
+    /** Gutter values for spacing utilities */
     guttersValues?: Record<'auto' | number, 'auto' | SizeUnit>;
 }
+/** Available feature keys for enabling/disabling CSS utilities */
 type RoleKeys = 'useMediaQueries' | 'useIcons' | 'useFontFamilies' | 'useFontSizes' | 'useFontShapes' | 'useTextAligns' | 'useTextTruncate' | 'useColors' | 'useColorsOpacities' | 'useColorsLightMode' | 'useColorsDarkMode' | 'useCurrentColors' | 'useRootColors' | 'useGrid' | 'useFlex' | 'useTransitions' | 'useWrappers' | 'useShadows' | 'useDisplays' | 'useOverflows' | 'useOpacities' | 'useBlur' | 'useObjectFits' | 'usePositions' | 'useInsets' | 'useSizes' | 'useGutters' | 'useBorders' | 'useTextBorders' | 'useRadius';
+/** Feature toggles for enabling/disabling CSS utility generation. @default all true */
 type Roles = Partial<Record<RoleKeys, boolean>>;
+/** Main theme configuration object containing all design system settings */
 interface Theme {
+    /** Color palette definitions with light/dark theme support */
     colors?: ColorType;
+    /** Typography settings including fonts, sizes, and weights */
     typography?: Typography;
+    /** Framework settings for grid, spacing, and responsive behavior */
     settings?: Settings;
+    /** Feature flags for controlling which CSS utilities are generated */
     roles?: Roles;
 }
 export type { SizeUnit, ColorType, FontWeight, FontStyle, FontVariant, FontType, Typography, Settings, RoleKeys, Roles, Theme, };

package/dist/scripts/types.js

@@ -1 +1,2 @@
+// General Types
 export {};