lapikit 0.0.0-insiders.a2a7a4d → 0.0.0-insiders.b14f086

package/bin/helper.js

@@ -0,0 +1,65 @@
+export const color = {
+	red: `\x1b[31m${text}\x1b[0m`,
+	green: `\x1b[32m${text}\x1b[0m`,
+	yellow: `\x1b[33m${text}\x1b[0m`,
+	blue: `\x1b[34m${text}\x1b[0m`,
+	purple: `\x1b[35m${text}\x1b[0m`,
+	cyan: `\x1b[36m${text}\x1b[0m`
+};
+
+export const variant = {
+	bold: `\x1b[1m${text}\x1b[0m`,
+	underline: `\x1b[4m${text}\x1b[0m`,
+	inverse: `\x1b[7m${text}\x1b[0m`
+};
+
+export const bold = {
+	red: `\x1b[1m\x1b[31m${text}\x1b[0m`,
+	green: `\x1b[1m\x1b[32m${text}\x1b[0m`,
+	yellow: `\x1b[1m\x1b[33m${text}\x1b[0m`,
+	blue: `\x1b[1m\x1b[34m${text}\x1b[0m`,
+	purple: `\x1b[1m\x1b[35m${text}\x1b[0m`,
+	cyan: `\x1b[1m\x1b[36m${text}\x1b[0m`
+};
+
+export const inverse = {
+	red: `\x1b[7m\x1b[31m${text}\x1b[0m`,
+	green: `\x1b[7m\x1b[32m${text}\x1b[0m`,
+	yellow: `\x1b[7m\x1b[33m${text}\x1b[0m`,
+	blue: `\x1b[7m\x1b[34m${text}\x1b[0m`,
+	purple: `\x1b[7m\x1b[35m${text}\x1b[0m`,
+	cyan: `\x1b[7m\x1b[36m${text}\x1b[0m`
+};
+
+export const underline = {
+	red: `\x1b[4m\x1b[31m${text}\x1b[0m`,
+	green: `\x1b[4m\x1b[32m${text}\x1b[0m`,
+	yellow: `\x1b[4m\x1b[33m${text}\x1b[0m`,
+	blue: `\x1b[4m\x1b[34m${text}\x1b[0m`,
+	purple: `\x1b[4m\x1b[35m${text}\x1b[0m`,
+	cyan: `\x1b[4m\x1b[36m${text}\x1b[0m`
+};
+
+export const terminal = (type = 'info', msg) => {
+	const name = ansi.color.cyan('lapikit');
+
+	if (type === 'error') console.error(name, ansi.bold.red('[error]'), msg);
+	else if (type === 'warn') console.warn(name, ansi.bold.yellow('[warn]'), msg);
+	else if (type === 'success') console.warn(name, ansi.bold.green('[success]'), msg);
+	else console.log(name, ansi.bold.blue('[info]'), msg);
+};
+
+export function getCssPathFromArgs() {
+	const args = process.argv.slice(2);
+	return args[1] || 'src/app.css';
+}
+
+export async function envTypescript() {
+	const directory = process.cwd();
+	try {
+		await fs.readFile(path.resolve(directory, 'tsconfig.json'), 'utf-8');
+		return true;
+	} catch {
+		return false;
+	}
+}

package/bin/lapikit.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { color, bold, variant, terminal, envTypescript } from './helper';
+import { preset } from './modules/preset';
+import { adapterCSSConfig, adapterViteConfig } from './modules/adapter';
+
+const [, , command] = process.argv;
+const typescriptEnabled = envTypescript();
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+	terminal(
+		'info',
+		`usage: ${color.yellow('npx lapikit init {cssPath}')}\n\n ${variant.bold('options:')}\n
+        - {cssPath}: (${color.cyan('src/app.css')}) customize path on your origin css file.\n\n`
+	);
+	process.exit(0);
+} else if (command === 'init') {
+	console.log('  _                 _ _    _ _   ');
+	console.log(' | |               (_) |  (_) |  ');
+	console.log(' | |     __ _ _ __  _| | ___| |_ ');
+	console.log(" | |    / _` | '_ \\| | |/ / | __|");
+	console.log(' | |___| (_| | |_) | |   <| | |_ ');
+	console.log(' |______\\__,_| .__/|_|_|\\_\\_|\\__|');
+	console.log('             | |                 ');
+	console.log('             |_|                 ');
+
+	terminal('info', `${bold.blue('LAPIKIT')} - Component Library for Svelte\n\n`);
+
+	const configPath = path.resolve(process.cwd(), 'lapikit.config.js');
+	try {
+		await fs.writeFile(configPath, preset.trim() + '\n', 'utf8');
+		terminal('success', `has create lapikit.config.js on your project.`);
+	} catch (error) {
+		terminal('error', `failed to create configuration file:\n\n ${error}`);
+		terminal(
+			'warn',
+			`you can create lapikit.config.js manually, please visite https://localhost:3000/docs for more information`
+		);
+	}
+
+	await adapterViteConfig(typescriptEnabled);
+	await adapterCSSConfig();
+
+	terminal(
+		'info',
+		`${bold.blue('Thank to use lapikit, discover all posibility with lapikit on https://localhost:3000/docs')}\n\n`
+	);
+
+	console.log('Github: https://github.com/nycolaide/lapikit');
+	console.log('Support the developement: https://buymeacoffee.com/nycolaide');
+} else {
+	terminal('error', `Command not recognized. Try 'npx lapikit init'`);
+}

package/bin/modules/adapter.js

@@ -0,0 +1,52 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getCssPathFromArgs, terminal } from '../helper';
+
+const importLapikitVite = `import { lapikit } from 'lapikit/vite';`;
+const importLapikitCss = `@import 'lapikit/css';`;
+
+export async function adapterViteConfig(typescript) {
+	const viteConfigPath = path.resolve(process.cwd(), `vite.config.${typescript ? 'ts' : 'js'}`);
+	try {
+		let viteConfig = await fs.readFile(viteConfigPath, 'utf8');
+
+		if (!viteConfig.includes(`${importLapikitVite}`))
+			viteConfig = `${importLapikitVite}\n` + viteConfig;
+
+		const pluginsRegex = /plugins:\s*\[([^\]]*)\]/;
+		const match = viteConfig.match(pluginsRegex);
+
+		if (match && !match[1].includes('lapikit()')) {
+			const updatedPlugins = match[1].trim() ? `${match[1].trim()}, lapikit()` : `lapikit()`;
+
+			viteConfig = viteConfig.replace(pluginsRegex, `plugins: [${updatedPlugins}]`);
+		}
+
+		await fs.writeFile(viteConfigPath, viteConfig, 'utf8');
+
+		terminal('success', 'lapikit() has added on vite.config.(js|ts) successfully');
+	} catch (error) {
+		terminal(
+			'error',
+			`lapikit encountered a problem while editing vite.config.(js|ts): \n\n ${error}`
+		);
+	}
+}
+
+export async function adapterCSSConfig() {
+	const cssPath = getCssPathFromArgs();
+	const resolvedPath = path.resolve(process.cwd(), cssPath);
+	try {
+		await fs.access(resolvedPath);
+		let appCssContent = await fs.readFile(resolvedPath, 'utf8');
+		appCssContent = `${importLapikitCss}\n\n` + appCssContent;
+		await fs.writeFile(resolvedPath, appCssContent, 'utf8');
+
+		terminal('success', `lapikit/css has added on ${cssPath}.`);
+	} catch (error) {
+		terminal(
+			'error',
+			`lapikit encountered a problem while editing ${cssPath}:\n\n  ${error.message}.`
+		);
+	}
+}

package/bin/modules/preset.js

@@ -0,0 +1,11 @@
+export const preset = `
+/** @type {import('lapikit').Config} */
+export default {
+	theme: {
+		colorScheme: 'light',
+		colors: {
+			svelte: '#ff3e00'
+		}
+	}
+};
+`;

package/dist/{server/modules → internal}/ansi.d.ts

@@ -38,4 +38,3 @@ export declare const ansi: {
     };
 };
 export type Ansi = typeof ansi;
-export declare const sendConsole: (type: "info" | "error" | "warn" | "success" | undefined, msg: string) => void;

package/dist/{server/modules → internal}/ansi.js

@@ -42,14 +42,3 @@ export const ansi = {
     inverse,
     underline
 };
-export const sendConsole = (type = 'info', msg) => {
-    const name = ansi.color.cyan('lapikit');
-    if (type === 'error')
-        console.error(name, ansi.bold.red('[error]'), msg);
-    else if (type === 'warn')
-        console.warn(name, ansi.bold.yellow('[warn]'), msg);
-    else if (type === 'success')
-        console.warn(name, ansi.bold.green('[success]'), msg);
-    else
-        console.log(name, ansi.bold.blue('[info]'), msg);
-};

package/dist/internal/colors.d.ts

@@ -0,0 +1 @@
+export declare const parseColor: (input: string) => string;

package/dist/internal/colors.js

@@ -0,0 +1,50 @@
+import { x11Colors } from '../utils/x11.js';
+export const parseColor = (input) => {
+    input = input.trim();
+    if (input.startsWith('#')) {
+        const rgb = hexToRgb(input);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    if (input.startsWith('rgb')) {
+        const parts = input
+            .replace(/rgba?|\(|\)|\s+/g, '')
+            .split(',')
+            .map(Number);
+        return rgbToOklch(parts[0], parts[1], parts[2]);
+    }
+    if (input.startsWith('oklch('))
+        return input;
+    if (x11Colors[input]) {
+        const hex = x11Colors[input];
+        const rgb = hexToRgb(hex);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    return input;
+};
+const hexToRgb = (hex) => {
+    const clean = hex.replace('#', '');
+    const bigint = parseInt(clean, 16);
+    return {
+        r: (bigint >> 16) & 255,
+        g: (bigint >> 8) & 255,
+        b: bigint & 255
+    };
+};
+const srgbToLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+const rgbToOklch = (r, g, b) => {
+    r = srgbToLinear(r / 255);
+    g = srgbToLinear(g / 255);
+    b = srgbToLinear(b / 255);
+    const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+    const a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+    const b_ = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+    const C = Math.sqrt(a * a + b_ * b_);
+    const h = (Math.atan2(b_, a) * 180) / Math.PI;
+    return `oklch(${(L * 100).toFixed(3)}% ${C.toFixed(4)} ${((h + 360) % 360).toFixed(2)})`;
+};

package/dist/internal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './terminal.js';
+export * from './ansi.js';

package/dist/internal/index.js

@@ -0,0 +1,2 @@
+export * from './terminal.js';
+export * from './ansi.js';

package/dist/internal/terminal.d.ts

@@ -0,0 +1 @@
+export declare const terminal: (type: "info" | "error" | "warn" | "success" | undefined, msg: string) => void;

package/dist/internal/terminal.js

@@ -0,0 +1,12 @@
+import { ansi } from './ansi.js';
+export const terminal = (type = 'info', msg) => {
+    const name = ansi.color.cyan('lapikit');
+    if (type === 'error')
+        console.error(name, ansi.bold.red('[error]'), msg);
+    else if (type === 'warn')
+        console.warn(name, ansi.bold.yellow('[warn]'), msg);
+    else if (type === 'success')
+        console.warn(name, ansi.bold.green('[success]'), msg);
+    else
+        console.log(name, ansi.bold.blue('[info]'), msg);
+};

package/dist/internal/types.d.ts

@@ -0,0 +1,44 @@
+export type FontFamily = {
+    [key: string]: string | string[];
+};
+export type Colors = {
+    [key: string]: {
+        light: string;
+        dark: string;
+    } | string;
+};
+export type Thresholds = {
+    [key: string]: number | string;
+};
+export type Radius = {
+    [key: string]: number | string;
+};
+export interface Lapikit {
+    options: {
+        normalize: boolean;
+        minify: boolean;
+    };
+    theme: {
+        colorScheme: string;
+        colors: Colors;
+    };
+    breakpoints: {
+        mobileBreakpoint: string;
+        tabletBreakpoint: string;
+        laptopBreakpoint: string;
+        thresholds: Thresholds;
+    };
+    styles: {
+        spacing: string;
+        corner: {
+            active: boolean;
+            radius: Radius;
+        };
+        font: FontFamily;
+    };
+}
+type DeepOptional<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepOptional<U>[] : T[P] extends object ? DeepOptional<T[P]> : T[P];
+};
+export type LapikitConfig = DeepOptional<Lapikit>;
+export {};

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/modules/config.d.ts

@@ -0,0 +1,2 @@
+import type { LapikitConfig } from '../../internal/types.js';
+export declare const parseConfig: (props?: LapikitConfig) => import("../../internal/types.js").Lapikit;

package/dist/plugin/modules/config.js

@@ -0,0 +1,54 @@
+import { config } from '../../preset.js';
+export const parseConfig = (props) => {
+    if (!props)
+        return config;
+    const newConfig = { ...config };
+    if (props?.options) {
+        if (props.options.normalize !== undefined)
+            newConfig.options.normalize = props.options.normalize;
+        if (props.options.minify !== undefined)
+            newConfig.options.minify = props.options.minify;
+    }
+    if (props?.theme) {
+        if (props.theme.colorScheme !== undefined)
+            newConfig.theme.colorScheme = props.theme.colorScheme;
+        if (props.theme.colors) {
+            newConfig.theme.colors = {
+                ...newConfig.theme.colors,
+                ...props.theme.colors
+            };
+        }
+    }
+    if (props?.breakpoints) {
+        if (props.breakpoints.mobileBreakpoint !== undefined)
+            newConfig.breakpoints.mobileBreakpoint = props.breakpoints.mobileBreakpoint;
+        if (props.breakpoints.tabletBreakpoint !== undefined)
+            newConfig.breakpoints.tabletBreakpoint = props.breakpoints.tabletBreakpoint;
+        if (props.breakpoints.laptopBreakpoint !== undefined)
+            newConfig.breakpoints.laptopBreakpoint = props.breakpoints.laptopBreakpoint;
+        if (props.breakpoints.thresholds)
+            newConfig.breakpoints.thresholds = {
+                ...newConfig.breakpoints.thresholds,
+                ...props.breakpoints.thresholds
+            };
+    }
+    if (props?.styles) {
+        if (props.styles.spacing !== undefined)
+            newConfig.styles.spacing = props.styles.spacing;
+        if (props.styles.corner !== undefined) {
+            if (props.styles.corner.active !== undefined)
+                newConfig.styles.corner.active = props.styles.corner.active;
+            if (props.styles.corner.radius)
+                newConfig.styles.corner.radius = {
+                    ...newConfig.styles.corner.radius,
+                    ...props.styles.corner.radius
+                };
+        }
+        if (props.styles.font)
+            newConfig.styles.font = {
+                ...newConfig.styles.font,
+                ...props.styles.font
+            };
+    }
+    return newConfig;
+};

package/dist/plugin/modules/importer.js

@@ -0,0 +1,15 @@
+import path from 'path';
+import fs from 'fs';
+import { terminal, ansi } from '../../internal/index.js';
+const app = process.cwd();
+const pathConfig = path.resolve(app, 'lapikit.config.js');
+export const importer = async () => {
+    if (!fs.existsSync(pathConfig)) {
+        terminal('error', `config file not found\n ${ansi.color.yellow('Could not find lapikit.config.js. See https://localhost/docs/kit/vite to learn more about the configuration file.')}\n\n${ansi.color.blue('for initializing a new lapikit config, run:')}\n        ${ansi.variant.bold('npx lapikit init')}    ${ansi.bold.yellow('(preview)')}\n\n`);
+        process.exit(1);
+    }
+    const timestamp = Date.now();
+    const fileUrl = `file://${pathConfig}?t=${timestamp}`;
+    const content = await import(fileUrl);
+    return content.default;
+};

package/dist/{server/vite.d.ts → plugin/vitejs.d.ts}

@@ -1,11 +1,6 @@
 import type { ViteDevServer } from 'vite';
-interface LapikitPlugin {
-    normalize?: boolean;
-    minify?: boolean;
-}
-export declare function lapikit(options?: LapikitPlugin): Promise<{
+export declare function lapikit(): Promise<{
     name: string;
     configResolved(): Promise<void>;
     configureServer(server: ViteDevServer): Promise<void>;
 }>;
-export {};

package/dist/plugin/vitejs.js

@@ -0,0 +1,26 @@
+import { importer } from './modules/importer.js';
+import { processCSS } from '../style/css.js';
+import { parseConfig } from './modules/config.js';
+import { terminal } from '../internal/terminal.js';
+export async function lapikit() {
+    return {
+        name: 'lapikit/vite.js',
+        async configResolved() {
+            const config = await importer();
+            const result = await parseConfig(config);
+            await processCSS(result);
+            terminal('info', 'lapikit is up!');
+        },
+        async configureServer(server) {
+            server.watcher.add('./lapikit.config.js');
+            server.watcher.on('change', async (filePath) => {
+                if (String(filePath).includes('lapikit.config.js')) {
+                    const config = await importer();
+                    const result = await parseConfig(config);
+                    await processCSS(result);
+                    terminal('info', 'lapikit config reloaded');
+                }
+            });
+        }
+    };
+}

package/dist/preset.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from './internal/types.js';
+export declare const config: Lapikit;

package/dist/preset.js

@@ -0,0 +1,80 @@
+export const config = {
+    options: {
+        normalize: true, // true | false
+        minify: false // true | false
+    },
+    theme: {
+        colorScheme: 'dark', // 'light' | 'dark' | 'auto'
+        colors: {
+            primary: { light: 'oklch(45% 0.24 277.023)', dark: 'oklch(45% 0.24 277.023)' },
+            secondary: { light: 'oklch(65% 0.241 354.308)', dark: 'oklch(65% 0.241 354.308)' },
+            tertiary: { light: 'oklch(77% 0.152 181.912)', dark: 'oklch(77% 0.152 181.912)' },
+            neutral: { light: 'oklch(14% 0.005 285.823)', dark: 'oklch(14% 0.005 285.823)' },
+            info: { light: 'oklch(74% 0.16 232.661)', dark: 'oklch(74% 0.16 232.661)' },
+            success: { light: 'oklch(76% 0.177 163.223)', dark: 'oklch(76% 0.177 163.223)' },
+            warning: { light: 'oklch(82% 0.189 84.429)', dark: 'oklch(82% 0.189 84.429)' },
+            error: { light: 'oklch(71% 0.194 13.428)', dark: 'oklch(71% 0.194 13.428)' },
+            base: { light: 'oklch(100% 0 0)', dark: 'oklch(25.33% 0.016 252.42)' },
+            surface: { light: 'oklch(98% 0 0)', dark: 'oklch(23.26% 0.014 253.1)' },
+            container: { light: 'oklch(95% 0 0)', dark: 'oklch(21.15% 0.012 254.09)' },
+            shadow: 'black'
+        }
+    },
+    breakpoints: {
+        mobileBreakpoint: 'sm',
+        tabletBreakpoint: 'md',
+        laptopBreakpoint: 'xl',
+        thresholds: {
+            none: 0, // 0px
+            xs: '28rem', //448px
+            sm: '40rem', //640px
+            md: '48rem', //768px
+            lg: '64rem', //1024px
+            xl: '80rem', //1280px
+            '2xl': '96rem', //1536px
+            '3xl': '112rem' //1792px
+        }
+    },
+    styles: {
+        spacing: '0.125rem', // 2px
+        corner: {
+            active: true, // true | false
+            radius: {
+                sm: '0.125rem', // 2px
+                md: '0.25rem', // 4px
+                lg: '0.5rem', // 8px
+                xl: '0.75rem', // 12px
+                '2xl': '1rem', // 16px
+                '3xl': '1.5rem', // 24px
+                full: '9999px' // 9999px
+            }
+        },
+        font: {
+            sans: [
+                'system-ui',
+                '-apple-system',
+                'BlinkMacSystemFont',
+                'Segoe UI',
+                'Roboto',
+                'Helvetica Neue',
+                'Arial',
+                'sans-serif',
+                'Apple Color Emoji',
+                'Segoe UI Emoji',
+                'Segoe UI Symbol'
+            ],
+            mono: [
+                'SFMono-Regular',
+                'ui-monospace',
+                'SF Mono',
+                'Menlo',
+                'Monaco',
+                'Consolas',
+                'Liberation Mono',
+                'Courier New',
+                'monospace'
+            ],
+            serif: ['Merriweather', 'Georgia', 'Cambria', 'Times New Roman', 'Times', 'serif']
+        }
+    }
+};

package/dist/style/css.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from '../internal/types.js';
+export declare const processCSS: (config: Lapikit) => Promise<void>;

package/dist/style/css.js

@@ -0,0 +1,31 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { minify } from '../internal/minify.js';
+import { colors, component, devices, variables } from './parser/index.js';
+import { terminal } from '../internal/terminal.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const __components = path.resolve('src/components');
+export const processCSS = async (config) => {
+    const _normalize = fs.readFileSync(path.resolve(__dirname, './normalize.css'), 'utf-8');
+    let styles = ``;
+    if (config.options.normalize)
+        styles += `${_normalize}\n`;
+    const colorScheme = colors(config);
+    const deviceDisplay = devices(config);
+    const variablesStyles = variables(config);
+    styles += `${colorScheme.root}\n`;
+    styles += `${variablesStyles}\n`;
+    styles += `${colorScheme.className}\n`;
+    styles += `${deviceDisplay}\n`;
+    if (fs.existsSync(__components) && fs.statSync(__components).isDirectory())
+        styles += component(config);
+    if (config.options.minify) {
+        styles = minify(styles);
+        terminal('success', 'css minified');
+    }
+    fsPromises.writeFile(path.resolve(__dirname, '../styles.css'), styles);
+};

package/dist/{styles → style}/normalize.css

@@ -3,12 +3,12 @@ html {
 	tab-size: 4;
 	line-height: 1.5;
 	box-sizing: border-box;
-	font-family: var(--font-sans, var(--kit-font-family-sans));
+	font-family: var(--kit-font-family-sans);
 }
 
 pre,
 code {
-	font-family: var(--font-mono, var(--kit-font-family-mono));
+	font-family: var(--kit-font-family-mono);
 }
 
 body {

package/dist/style/parser/color.d.ts

@@ -0,0 +1,5 @@
+import type { Lapikit } from '../../internal/types.js';
+export declare const colors: (config: Lapikit) => {
+    root: string;
+    className: string;
+};

package/dist/style/parser/color.js

@@ -0,0 +1,77 @@
+import { parseColor } from '../../internal/colors.js';
+export const colors = (config) => {
+    const schemes = {
+        light: {},
+        dark: {}
+    };
+    for (const [property, values] of Object.entries(config.theme.colors)) {
+        if (typeof values === 'string') {
+            // for all color scheme
+            const _refColor = parseColor(values);
+            schemes['light'][property] = _refColor;
+            schemes['dark'][property] = _refColor;
+        }
+        else {
+            // with specification
+            if ('light' in values && 'dark' in values) {
+                schemes['light'][property] = parseColor(values.light);
+                schemes['dark'][property] = parseColor(values.dark);
+            }
+            else {
+                const _refColor = 'dark' in values ? parseColor(values['dark']) : parseColor(values['light']);
+                schemes['light'][property] = _refColor;
+                schemes['dark'][property] = _refColor;
+            }
+        }
+    }
+    // css variables
+    let cssVariables = '';
+    if (config.theme.colorScheme === 'auto') {
+        for (const [themeName, colors] of Object.entries(schemes)) {
+            const used = themeName;
+            const inversed = used === 'light' ? 'dark' : 'light';
+            cssVariables += `@media (prefers-color-scheme: ${used}) {\n`;
+            cssVariables += `:root, .${used} {\n`;
+            cssVariables += `color-scheme: ${used};\n`;
+            for (const [colorName, colorValue] of Object.entries(colors)) {
+                cssVariables += `--kit-${colorName}: ${colorValue};\n`;
+            }
+            cssVariables += `}\n`;
+            cssVariables += `.${inversed} {\n`;
+            cssVariables += `color-scheme: ${used};\n`;
+            for (const [colorName, colorValue] of Object.entries(schemes[inversed])) {
+                cssVariables += `--kit-${colorName}: ${colorValue};\n`;
+            }
+            cssVariables += `}\n`;
+            cssVariables += `}\n`;
+        }
+    }
+    else {
+        const used = config.theme.colorScheme;
+        const inversed = config.theme.colorScheme === 'light' ? 'dark' : 'light';
+        cssVariables += `:root, .${used} {\n`;
+        cssVariables += `color-scheme: ${used};\n`;
+        for (const [colorName, colorValue] of Object.entries(schemes[used])) {
+            cssVariables += `--kit-${colorName}: ${colorValue};\n`;
+        }
+        cssVariables += `}\n`;
+        cssVariables += `.${inversed} {\n`;
+        cssVariables += `color-scheme: ${used};\n`;
+        for (const [colorName, colorValue] of Object.entries(schemes[inversed])) {
+            cssVariables += `--kit-${colorName}: ${colorValue};\n`;
+        }
+        cssVariables += `}\n`;
+    }
+    // class
+    let classStyles = '';
+    for (const [property] of Object.entries(schemes.light)) {
+        classStyles += `.${property} {\n`;
+        classStyles += `--background-color: var(--kit-${property});\n`;
+        classStyles += `--color: var(--kit-${property});\n`;
+        classStyles += `}\n`;
+    }
+    return {
+        root: cssVariables,
+        className: classStyles
+    };
+};

package/dist/style/parser/component.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from '../../internal/types.js';
+export declare const component: (config: Lapikit) => string;

package/dist/style/parser/component.js

@@ -0,0 +1,115 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const component = (config) => {
+    let css = ``;
+    const tresholds = {
+        _default: '',
+        static: '',
+        min: '',
+        max: '',
+        all: ''
+    };
+    function loadComponentCSS(directory) {
+        fs.readdirSync(directory).forEach((File) => {
+            const absolutePath = path.join(directory, File);
+            if (fs.statSync(absolutePath).isDirectory())
+                return loadComponentCSS(absolutePath);
+            else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
+                const content = parser(fs.readFileSync(absolutePath, 'utf-8'));
+                tresholds._default += content.allExtracted
+                    .replaceAll('[breakpoint|min]', '[breakpoint]')
+                    .replaceAll('[breakpoint|max]', '[breakpoint]')
+                    .replaceAll('[breakpoint|all]', '[breakpoint]');
+                tresholds.static += content.defaultExtracted;
+                tresholds.min += content.minExtracted.replaceAll('[breakpoint|min]', '[breakpoint]');
+                tresholds.max += content.maxExtracted.replaceAll('[breakpoint|max]', '[breakpoint]');
+                tresholds.all += content.allModifierExtracted.replaceAll('[breakpoint|all]', '[breakpoint]');
+                return (css += `${content.cleaned}\n`);
+            }
+        });
+    }
+    loadComponentCSS(path.resolve(__dirname, '../../components'));
+    for (const property in config.breakpoints.thresholds) {
+        if (property !== '_default') {
+            const name = `.${/^\d/.test(property) ? `\\3${property}` : property}\\:`;
+            const value = typeof config.breakpoints.thresholds[property] === 'number'
+                ? `${config.breakpoints.thresholds[property]}px`
+                : config.breakpoints.thresholds[property];
+            if (tresholds.static !== '' || tresholds.all !== '' || tresholds.min !== '') {
+                css += `@media screen and (min-width: ${value}) {\n`;
+                if (tresholds.static !== '')
+                    css += tresholds.static.replaceAll('[breakpoint]', name);
+                if (tresholds.all !== '')
+                    css += tresholds.all.replaceAll('[breakpoint]', name);
+                if (tresholds.min !== '')
+                    css += tresholds.min.replaceAll('[breakpoint]', name);
+                css += `}\n`;
+            }
+            if (tresholds.max !== '' || tresholds.all !== '') {
+                css += `@media screen and (max-width: ${value}) {\n`;
+                if (tresholds.max !== '')
+                    css += tresholds.max.replaceAll('[breakpoint]', name);
+                if (tresholds.all !== '')
+                    css += tresholds.all.replaceAll('[breakpoint]', name);
+                css += `}\n`;
+            }
+        }
+        else {
+            css += tresholds._default.replaceAll('[breakpoint]', '.');
+        }
+    }
+    return css;
+};
+const parser = (css) => {
+    const regex = /([^{]+)\{([^}]+)\}/g;
+    let match;
+    const matchesToRemove = [];
+    const extractedByType = {
+        allExtracted: [],
+        defaultExtracted: [],
+        minExtracted: [],
+        maxExtracted: [],
+        allModifierExtracted: []
+    };
+    while ((match = regex.exec(css)) !== null) {
+        const fullMatch = match[0];
+        const selectors = match[1].trim();
+        const body = match[2].trim();
+        const selectorsArray = selectors.split(',').map((sel) => sel.trim());
+        let matchedType = null;
+        if (selectorsArray.some((sel) => sel.includes('[breakpoint|min]'))) {
+            matchedType = 'minExtracted';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|max]'))) {
+            matchedType = 'maxExtracted';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|all]'))) {
+            matchedType = 'allModifierExtracted';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint]'))) {
+            matchedType = 'defaultExtracted';
+        }
+        if (matchedType) {
+            const rule = `${selectors} {\n${body}\n}`;
+            extractedByType.allExtracted.push(rule);
+            extractedByType[matchedType].push(rule);
+            matchesToRemove.push(fullMatch);
+        }
+    }
+    let cleaned = css;
+    for (const rule of matchesToRemove) {
+        cleaned = cleaned.replace(rule, '').replace(/\n{2,}/g, '\n\n');
+    }
+    return {
+        allExtracted: extractedByType.allExtracted.join('\n\n').trim(),
+        defaultExtracted: extractedByType.defaultExtracted.join('\n\n').trim(),
+        minExtracted: extractedByType.minExtracted.join('\n\n').trim(),
+        maxExtracted: extractedByType.maxExtracted.join('\n\n').trim(),
+        allModifierExtracted: extractedByType.allModifierExtracted.join('\n\n').trim(),
+        cleaned: cleaned.trim()
+    };
+};

package/dist/style/parser/device.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from '../../internal/types.js';
+export declare const devices: (config: Lapikit) => string;

package/dist/style/parser/device.js

@@ -0,0 +1,28 @@
+export const devices = (config) => {
+    let css = ``;
+    const list = {
+        mobile: config.breakpoints.mobileBreakpoint,
+        tablet: config.breakpoints.tabletBreakpoint,
+        laptop: config.breakpoints.laptopBreakpoint
+    };
+    for (const [key, value] of Object.entries(list)) {
+        const breakpointValue = config.breakpoints.thresholds[value];
+        const breakpointValueMax = key !== 'laptop'
+            ? config.breakpoints.thresholds[key === 'mobile' ? list.tablet : key == 'tablet' ? list.laptop : '']
+            : undefined;
+        css += `.device-${key}, .only-on-${key} {\n`;
+        css += `display: none;\n`;
+        css += `}\n`;
+        css += `@media screen and (min-width: ${typeof breakpointValue === 'number' ? breakpointValue + 'px' : breakpointValue}) {\n`;
+        css += `.device-${key} {\n`;
+        css += `display: inherit !important;\n`;
+        css += `}\n`;
+        css += `}\n`;
+        css += `@media screen and (min-width: ${typeof breakpointValue === 'number' ? breakpointValue + 'px' : breakpointValue}) ${breakpointValueMax ? `and (max-width: ${typeof breakpointValueMax === 'number' ? breakpointValueMax + 'px' : breakpointValueMax})` : ''}{\n`;
+        css += `.only-on-${key} {\n`;
+        css += `display: inherit !important;\n`;
+        css += `}\n`;
+        css += `}\n`;
+    }
+    return css;
+};

package/dist/style/parser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './color.js';
+export * from './component.js';
+export * from './device.js';
+export * from './variable.js';

package/dist/style/parser/index.js

@@ -0,0 +1,4 @@
+export * from './color.js';
+export * from './component.js';
+export * from './device.js';
+export * from './variable.js';

package/dist/style/parser/variable.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from '../../internal/types.js';
+export declare const variables: (config?: Lapikit) => string;

package/dist/style/parser/variable.js

@@ -0,0 +1,25 @@
+export const variables = (config) => {
+    if (!config)
+        return '';
+    const { styles } = config;
+    let css = ``;
+    css += `:root {\n`;
+    css += `\t--kit-spacing: ${parser(styles.spacing)};\n`;
+    if (styles.corner.active) {
+        for (const [key, value] of Object.entries(styles.corner.radius)) {
+            css += `\t--kit-radius-${key}: ${typeof value === 'number' ? value + 'px' : value};\n`;
+        }
+    }
+    for (const [key, value] of Object.entries(styles.font)) {
+        css += `\t--kit-font-family-${key}: ${parser(value)};\n`;
+    }
+    css += `}\n`;
+    return css;
+};
+const parser = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value;
+};

package/dist/utils/x11.d.ts

@@ -0,0 +1,4 @@
+export declare const x11Colors: {
+    [key: string]: string;
+};
+export declare const x11ColorNames: string[];

package/dist/utils/x11.js

@@ -0,0 +1,151 @@
+export const x11Colors = {
+    aliceblue: '#F0F8FF',
+    antiquewhite: '#FAEBD7',
+    aqua: '#00FFFF',
+    aquamarine: '#7FFFD4',
+    azure: '#F0FFFF',
+    beige: '#F5F5DC',
+    bisque: '#FFE4C4',
+    black: '#000000',
+    blanchedalmond: '#FFEBCD',
+    blue: '#0000FF',
+    blueviolet: '#8A2BE2',
+    brown: '#A52A2A',
+    burlywood: '#DEB887',
+    cadetblue: '#5F9EA0',
+    chartreuse: '#7FFF00',
+    chocolate: '#D2691E',
+    coral: '#FF7F50',
+    cornflowerblue: '#6495ED',
+    cornsilk: '#FFF8DC',
+    crimson: '#DC143C',
+    cyan: '#00FFFF',
+    darkblue: '#00008B',
+    darkcyan: '#008B8B',
+    darkgoldenrod: '#B8860B',
+    darkgray: '#A9A9A9',
+    darkgrey: '#A9A9A9',
+    darkgreen: '#006400',
+    darkkhaki: '#BDB76B',
+    darkmagenta: '#8B008B',
+    darkolivegreen: '#556B2F',
+    darkorange: '#FF8C00',
+    darkorchid: '#9932CC',
+    darkred: '#8B0000',
+    darksalmon: '#E9967A',
+    darkseagreen: '#8FBC8F',
+    darkslateblue: '#483D8B',
+    darkslategray: '#2F4F4F',
+    darkslategrey: '#2F4F4F',
+    darkturquoise: '#00CED1',
+    darkviolet: '#9400D3',
+    deeppink: '#FF1493',
+    deepskyblue: '#00BFFF',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1E90FF',
+    firebrick: '#B22222',
+    floralwhite: '#FFFAF0',
+    forestgreen: '#228B22',
+    fuchsia: '#FF00FF',
+    gainsboro: '#DCDCDC',
+    ghostwhite: '#F8F8FF',
+    gold: '#FFD700',
+    goldenrod: '#DAA520',
+    gray: '#808080',
+    grey: '#808080',
+    green: '#008000',
+    greenyellow: '#ADFF2F',
+    honeydew: '#F0FFF0',
+    hotpink: '#FF69B4',
+    indianred: '#CD5C5C',
+    indigo: '#4B0082',
+    ivory: '#FFFFF0',
+    khaki: '#F0E68C',
+    lavender: '#E6E6FA',
+    lavenderblush: '#FFF0F5',
+    lawngreen: '#7CFC00',
+    lemonchiffon: '#FFFACD',
+    lightblue: '#ADD8E6',
+    lightcoral: '#F08080',
+    lightcyan: '#E0FFFF',
+    lightgoldenrodyellow: '#FAFAD2',
+    lightgray: '#D3D3D3',
+    lightgrey: '#D3D3D3',
+    lightgreen: '#90EE90',
+    lightpink: '#FFB6C1',
+    lightsalmon: '#FFA07A',
+    lightseagreen: '#20B2AA',
+    lightskyblue: '#87CEFA',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#B0C4DE',
+    lightyellow: '#FFFFE0',
+    lime: '#00FF00',
+    limegreen: '#32CD32',
+    linen: '#FAF0E6',
+    magenta: '#FF00FF',
+    maroon: '#800000',
+    mediumaquamarine: '#66CDAA',
+    mediumblue: '#0000CD',
+    mediumorchid: '#BA55D3',
+    mediumpurple: '#9370DB',
+    mediumseagreen: '#3CB371',
+    mediumslateblue: '#7B68EE',
+    mediumspringgreen: '#00FA9A',
+    mediumturquoise: '#48D1CC',
+    mediumvioletred: '#C71585',
+    midnightblue: '#191970',
+    mintcream: '#F5FFFA',
+    mistyrose: '#FFE4E1',
+    moccasin: '#FFE4B5',
+    navajowhite: '#FFDEAD',
+    navy: '#000080',
+    oldlace: '#FDF5E6',
+    olive: '#808000',
+    olivedrab: '#6B8E23',
+    orange: '#FFA500',
+    orangered: '#FF4500',
+    orchid: '#DA70D6',
+    palegoldenrod: '#EEE8AA',
+    palegreen: '#98FB98',
+    paleturquoise: '#AFEEEE',
+    palevioletred: '#DB7093',
+    papayawhip: '#FFEFD5',
+    peachpuff: '#FFDAB9',
+    peru: '#CD853F',
+    pink: '#FFC0CB',
+    plum: '#DDA0DD',
+    powderblue: '#B0E0E6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#FF0000',
+    rosybrown: '#BC8F8F',
+    royalblue: '#4169E1',
+    saddlebrown: '#8B4513',
+    salmon: '#FA8072',
+    sandybrown: '#F4A460',
+    seagreen: '#2E8B57',
+    seashell: '#FFF5EE',
+    sienna: '#A0522D',
+    silver: '#C0C0C0',
+    skyblue: '#87CEEB',
+    slateblue: '#6A5ACD',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#FFFAFA',
+    springgreen: '#00FF7F',
+    steelblue: '#4682B4',
+    tan: '#D2B48C',
+    teal: '#008080',
+    thistle: '#D8BFD8',
+    tomato: '#FF6347',
+    turquoise: '#40E0D0',
+    violet: '#EE82EE',
+    wheat: '#F5DEB3',
+    white: '#FFFFFF',
+    whitesmoke: '#F5F5F5',
+    yellow: '#FFFF00',
+    yellowgreen: '#9ACD32'
+};
+export const x11ColorNames = Object.keys(x11Colors);

package/package.json

@@ -1,6 +1,14 @@
 {
 	"name": "lapikit",
-	"version": "0.0.0-insiders.a2a7a4d",
+	"version": "0.0.0-insiders.b14f086",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Nycolaide/lapikit.git",
+		"directory": "packages/lapikit"
+	},
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -14,10 +22,8 @@
 		"test:unit": "vitest",
 		"test": "npm run test:unit -- --run"
 	},
-	"publishConfig": {
-		"access": "public"
-	},
 	"files": [
+		"bin",
 		"dist",
 		"!dist/**/*.test.*",
 		"!dist/**/*.spec.*"
@@ -34,7 +40,7 @@
 			"svelte": "./dist/index.js"
 		},
 		"./vite": {
-			"default": "./dist/server/vite.js"
+			"default": "./dist/plugin/vitejs.js"
 		},
 		"./css": "./dist/styles.css"
 	},

package/dist/server/modules/css.d.ts

@@ -1 +0,0 @@
-export declare const processCSS: (minified?: boolean, normalize?: boolean) => Promise<void>;

package/dist/server/modules/css.js

@@ -1,137 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import fs from 'fs';
-import fsPromises from 'fs/promises';
-import path from 'path';
-import { ansi, sendConsole } from './ansi.js';
-import { minify } from './minify.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const __components = path.resolve('src/components');
-// temps
-const breakpoints = {
-    _default: 0,
-    desktop: 1024,
-    tablet: '768vw',
-    mobile: 480
-};
-export const processCSS = async (minified, normalize) => {
-    console.log(ansi.bold.blue('Processing CSS...'));
-    const _normalize = fs.readFileSync(path.resolve(__dirname, '../../styles/normalize.css'), 'utf-8');
-    const _variables = fs.readFileSync(path.resolve(__dirname, '../../styles/variables.css'), 'utf-8');
-    let styles = `${_variables}\n`;
-    if (normalize)
-        styles += `${_normalize}\n`;
-    if (fs.existsSync(__components) && fs.statSync(__components).isDirectory()) {
-        const tresholds = {
-            _default: '',
-            static: '',
-            min: '',
-            max: '',
-            all: ''
-        };
-        function loadComponentCSS(directory) {
-            fs.readdirSync(directory).forEach((File) => {
-                const absolutePath = path.join(directory, File);
-                if (fs.statSync(absolutePath).isDirectory())
-                    return loadComponentCSS(absolutePath);
-                else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
-                    const content = parser(fs.readFileSync(absolutePath, 'utf-8'));
-                    tresholds._default += content.allExtracted
-                        .replaceAll('[breakpoint|min]', '[breakpoint]')
-                        .replaceAll('[breakpoint|max]', '[breakpoint]')
-                        .replaceAll('[breakpoint|all]', '[breakpoint]');
-                    tresholds.static += content.defaultExtracted;
-                    tresholds.min += content.minExtracted.replaceAll('[breakpoint|min]', '[breakpoint]');
-                    tresholds.max += content.maxExtracted.replaceAll('[breakpoint|max]', '[breakpoint]');
-                    tresholds.all += content.allModifierExtracted.replaceAll('[breakpoint|all]', '[breakpoint]');
-                    return (styles += `${content.cleaned}\n`);
-                }
-            });
-        }
-        loadComponentCSS(path.resolve(__dirname, '../../components'));
-        for (const property in breakpoints) {
-            if (property !== '_default') {
-                const name = `.${/^\d/.test(property) ? `\\3${property}` : property}\\:`;
-                const value = typeof breakpoints[property] === 'number'
-                    ? `${breakpoints[property]}px`
-                    : breakpoints[property];
-                if (tresholds.static !== '' || tresholds.all !== '' || tresholds.min !== '') {
-                    styles += `@media screen and (min-width: ${value}) {\n`;
-                    if (tresholds.static !== '')
-                        styles += tresholds.static.replaceAll('[breakpoint]', name);
-                    if (tresholds.all !== '')
-                        styles += tresholds.all.replaceAll('[breakpoint]', name);
-                    if (tresholds.min !== '')
-                        styles += tresholds.min.replaceAll('[breakpoint]', name);
-                    styles += `}\n`;
-                }
-                if (tresholds.max !== '' || tresholds.all !== '') {
-                    styles += `@media screen and (max-width: ${value}) {\n`;
-                    if (tresholds.max !== '')
-                        styles += tresholds.max.replaceAll('[breakpoint]', name);
-                    if (tresholds.all !== '')
-                        styles += tresholds.all.replaceAll('[breakpoint]', name);
-                    styles += `}\n`;
-                }
-            }
-            else {
-                styles += tresholds._default.replaceAll('[breakpoint]', '.');
-            }
-        }
-    }
-    if (minified) {
-        styles = minify(styles);
-        sendConsole('success', 'css minified');
-    }
-    fsPromises.writeFile(path.resolve(__dirname, '../../styles.css'), styles);
-};
-const parser = (css) => {
-    const regex = /([^{]+)\{([^}]+)\}/g;
-    let match;
-    const matchesToRemove = [];
-    const extractedByType = {
-        allExtracted: [],
-        defaultExtracted: [],
-        minExtracted: [],
-        maxExtracted: [],
-        allModifierExtracted: []
-    };
-    while ((match = regex.exec(css)) !== null) {
-        const fullMatch = match[0];
-        const selectors = match[1].trim();
-        const body = match[2].trim();
-        const selectorsArray = selectors.split(',').map((sel) => sel.trim());
-        let matchedType = null;
-        if (selectorsArray.some((sel) => sel.includes('[breakpoint|min]'))) {
-            matchedType = 'minExtracted';
-        }
-        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|max]'))) {
-            matchedType = 'maxExtracted';
-        }
-        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|all]'))) {
-            matchedType = 'allModifierExtracted';
-        }
-        else if (selectorsArray.some((sel) => sel.includes('[breakpoint]'))) {
-            matchedType = 'defaultExtracted';
-        }
-        if (matchedType) {
-            const rule = `${selectors} {\n${body}\n}`;
-            extractedByType.allExtracted.push(rule);
-            extractedByType[matchedType].push(rule);
-            matchesToRemove.push(fullMatch);
-        }
-    }
-    let cleaned = css;
-    for (const rule of matchesToRemove) {
-        cleaned = cleaned.replace(rule, '').replace(/\n{2,}/g, '\n\n');
-    }
-    return {
-        allExtracted: extractedByType.allExtracted.join('\n\n').trim(),
-        defaultExtracted: extractedByType.defaultExtracted.join('\n\n').trim(),
-        minExtracted: extractedByType.minExtracted.join('\n\n').trim(),
-        maxExtracted: extractedByType.maxExtracted.join('\n\n').trim(),
-        allModifierExtracted: extractedByType.allModifierExtracted.join('\n\n').trim(),
-        cleaned: cleaned.trim()
-    };
-};

package/dist/server/modules/importer.js

@@ -1,13 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { ansi } from './ansi.js';
-const app = process.cwd();
-const pathConfig = path.resolve(app, 'lapikit.config.js');
-export const importer = async () => {
-    if (!fs.existsSync(pathConfig)) {
-        console.error(ansi.color.cyan('lapikit'), ansi.bold.red('[error]'), 'config file not found\n', ansi.color.yellow('Could not find lapikit.config.js. See https://localhost/docs/kit/vite to learn more about the configuration file.'), '\n\n', ansi.color.blue('for initializing a new lapikit config, run:\n'), '     ' + ansi.variant.bold('npx lapikit init') + '  ' + ansi.bold.yellow('(preview)'), '\n\n');
-        process.exit(1);
-    }
-    const content = await import(pathConfig);
-    return content.default;
-};

package/dist/server/vite.js

@@ -1,17 +0,0 @@
-import { ansi } from './modules/ansi.js';
-import { importer } from './modules/importer.js';
-import { processCSS } from './modules/css.js';
-export async function lapikit(options = {}) {
-    return {
-        name: 'lapikit/vite.js',
-        async configResolved() {
-            console.log(ansi.bold.blue('Vite plugin loaded'), options);
-            const config = await importer();
-            await processCSS(options.minify, options.normalize);
-            // console.log('config', config);
-        },
-        async configureServer(server) {
-            // console.log(ansi.inverse.red('Vite server configured'), server);
-        }
-    };
-}

package/dist/styles/variables.css

@@ -1,7 +0,0 @@
-:root {
-	--kit-font-family-sans:
-		system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
-		sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
-	--kit-font-family-mono: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace;
-	--kit-spacing: 0.25rem;
-}