lapikit 0.0.0-insiders.bd609af → 0.0.0-insiders.c3399e0

package/bin/configuration.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { promises as fs } from 'fs';
 import path from 'path';
+import { terminal } from './helper.js';
 import presets from './presets.js';
 
 async function findReferenceFile(projectPath) {
@@ -9,7 +10,8 @@ async function findReferenceFile(projectPath) {
 	try {
 		await fs.access(routesPath);
 	} catch {
-		throw new Error('Lapikit cannot find the routes/ directory.');
+		terminal('error', `Lapikit cannot find the routes/ directory.`);
+		// throw new Error('Lapikit cannot find the routes/ directory.');
 	}
 
 	const layoutFile = path.join(routesPath, '+layout.svelte');
@@ -65,7 +67,7 @@ async function addImportToReferenceFile(targetFile, referenceFile) {
 		const importStatement = `import "${relativePath.startsWith('.') ? relativePath : './' + relativePath}";\n`;
 
 		if (content.includes(`import "${relativePath}"`)) {
-			console.log(`import has already exist ${referenceFile}`);
+			terminal('info', `Import statement already exists in ${referenceFile}`);
 			return;
 		}
 
@@ -103,9 +105,9 @@ async function addImportToReferenceFile(targetFile, referenceFile) {
 		const newContent = lines.join('\n');
 
 		await fs.writeFile(referenceFile, newContent);
-		console.log(`Import has added on ${referenceFile}`);
+		terminal('info', `Import has been added to ${referenceFile}`);
 	} catch (error) {
-		console.error(`Error adding import: ${error.message}`);
+		terminal('error', `Error adding import: ${error.message}`);
 		throw error;
 	}
 }
@@ -131,14 +133,16 @@ async function findViteConfigFile(projectPath, typescript) {
 	}
 }
 
-async function addLapikitToViteConfig(viteConfigFile) {
+async function addLapikitToViteConfig(viteConfigFile, pathConfig, typescript) {
 	try {
 		const content = await fs.readFile(viteConfigFile, 'utf-8');
 		const lapikitImport = `import { lapikit } from 'lapikit/vite';`;
+		const configPath = `${pathConfig}/lapikit.${typescript ? 'ts' : 'js'}`;
+		const lapikitPlugin = `lapikit({ config: '${configPath}' })`;
 
 		// Check if lapikit import already exists
 		if (content.includes(lapikitImport) || content.includes(`from 'lapikit/vite'`)) {
-			console.log(`Lapikit import already exists in ${viteConfigFile}`);
+			terminal('info', `Lapikit import already exists in ${viteConfigFile}`);
 			return;
 		}
 
@@ -181,10 +185,10 @@ async function addLapikitToViteConfig(viteConfigFile) {
 					const pluginMatch = line.match(/plugins:\s*\[(.*)\]/);
 					if (pluginMatch) {
 						const pluginsContent = pluginMatch[1];
-						if (!pluginsContent.includes('lapikit()')) {
+						if (!pluginsContent.includes('lapikit')) {
 							const newPluginsContent = pluginsContent.replace(
 								/sveltekit\(\)/,
-								'sveltekit(), lapikit()'
+								`sveltekit(), ${lapikitPlugin}`
 							);
 							lines[i] = line.replace(pluginsContent, newPluginsContent);
 							pluginAdded = true;
@@ -198,24 +202,24 @@ async function addLapikitToViteConfig(viteConfigFile) {
 					const pluginLine = lines[j].trim();
 
 					if (pluginLine.includes('sveltekit()') && !pluginAdded) {
-						// Check if lapikit() is not already present
+						// Check if lapikit is not already present
 						let hasLapikit = false;
 						for (let k = i; k < lines.length && !lines[k].includes(']'); k++) {
-							if (lines[k].includes('lapikit()')) {
+							if (lines[k].includes('lapikit')) {
 								hasLapikit = true;
 								break;
 							}
 						}
 
 						if (!hasLapikit) {
-							// Add lapikit() after sveltekit()
+							// Add lapikit after sveltekit()
 							if (pluginLine.includes(',')) {
-								lines[j] = lines[j].replace('sveltekit()', 'sveltekit(), lapikit()');
+								lines[j] = lines[j].replace('sveltekit()', `sveltekit(), ${lapikitPlugin}`);
 							} else {
 								lines[j] = lines[j].replace('sveltekit()', 'sveltekit(),');
-								// Insert lapikit() on the next line with proper indentation
+								// Insert lapikit on the next line with proper indentation
 								const indentation = lines[j].match(/^\s*/)[0];
-								lines.splice(j + 1, 0, `${indentation}lapikit()`);
+								lines.splice(j + 1, 0, `${indentation}${lapikitPlugin}`);
 							}
 							pluginAdded = true;
 						}
@@ -231,21 +235,20 @@ async function addLapikitToViteConfig(viteConfigFile) {
 		}
 
 		if (!pluginAdded) {
-			console.warn('Could not find sveltekit() in plugins array to add lapikit() after it');
+			terminal('warn', `Could not find sveltekit() in plugins array to add lapikit() after it`);
 		}
 
 		const newContent = lines.join('\n');
 		await fs.writeFile(viteConfigFile, newContent);
-		console.log(`Lapikit import and plugin added to ${viteConfigFile}`);
+		terminal('info', `Lapikit import and plugin added to ${viteConfigFile}`);
 	} catch (error) {
-		console.error(`Error adding lapikit to vite config: ${error.message}`);
+		terminal('error', `Error adding lapikit to vite config: ${error.message}`);
 		throw error;
 	}
 }
 
 export async function initConfiguration(options) {
-	console.log('initConfiguration called with:', options);
-	const { typescript, pathConfig, formatCSS } = options;
+	const { typescript, pathConfig, formatCSS, pathCSS } = options;
 	const ext = typescript ? 'ts' : 'js';
 	const targetDir = path.resolve(process.cwd(), pathConfig);
 	const targetFile = path.join(targetDir, `lapikit.${ext}`);
@@ -253,30 +256,32 @@ export async function initConfiguration(options) {
 	await fs.mkdir(targetDir, { recursive: true });
 
 	let fileCreated = false;
+
+	// Create Lapikit config
 	try {
-		console.log(`Trying to access ${targetFile}`);
 		await fs.access(targetFile);
-		console.log(`File ${targetFile} already exists.`);
+		terminal('info', `File ${targetFile} already exists.`);
 	} catch {
-		console.log(`Creating file: ${targetFile}`);
+		terminal('info', `Creating file: ${targetFile}`);
 		const content = presets({
-			classic: formatCSS === 'global'
+			adapterCSS: formatCSS
 		});
 		await fs.writeFile(targetFile, content);
-		console.log(`File created : ${targetFile}`);
+		terminal('info', `File created: ${targetFile}`);
 		fileCreated = true;
 	}
 
+	// Add Import Lapikit plugin
 	try {
 		const referenceFile = await findReferenceFile(process.cwd());
 		await addImportToReferenceFile(targetFile, referenceFile);
 	} catch (error) {
-		console.error(`Error: ${error.message}`);
-		// If the file was just created and we can't add the import, delete it
+		terminal('error', `Error adding import: ${error.message}`);
+
 		if (fileCreated) {
 			try {
 				await fs.unlink(targetFile);
-				console.log(`File ${targetFile} deleted due to error.`);
+				terminal('info', `File ${targetFile} deleted due to error.`);
 			} catch {
 				// Ignore deletion error
 			}
@@ -284,12 +289,16 @@ export async function initConfiguration(options) {
 		throw error;
 	}
 
+	// Add Import Lapikit css
+	if (formatCSS !== 'css') {
+		console.log('need custom import (Preview)', pathCSS);
+	}
 	// Add lapikit to vite.config file
 	try {
 		const viteConfigFile = await findViteConfigFile(process.cwd(), typescript);
-		await addLapikitToViteConfig(viteConfigFile);
+		await addLapikitToViteConfig(viteConfigFile, pathConfig, typescript);
 	} catch (error) {
-		console.warn(`Warning: Could not update vite.config file: ${error.message}`);
-		// This is not a critical error, so we don't throw it
+		terminal('warn', `Warning: Could not update vite.config file: ${error.message}`);
+		terminal('error', `Error adding lapikit to vite config: ${error.message}`);
 	}
 }

package/bin/index.js

@@ -30,12 +30,12 @@ async function run() {
 
 run()
 	.then(() => {
-		console.log('Website: https://lapikit.dev');
-		console.log('Github: https://github.com/nycolaide/lapikit');
-		console.log('Support the developement: https://buymeacoffee.com/nycolaide');
+		terminal('none', `\n\n\n\nWebsite: https://lapikit.dev`);
+		terminal('none', `Github: https://github.com/nycolaide/lapikit`);
+		terminal('none', `Support the developement: https://buymeacoffee.com/nycolaide`);
 		process.exit(0);
 	})
 	.catch((error) => {
-		console.error(`\n${red('✖')} ${error}\n`);
+		terminal('error', `Error: ${error}`);
 		process.exit(1);
 	});

package/bin/presets.js

@@ -1,21 +1,24 @@
-function presets({ classic }) {
+function presets({ adapterCSS }) {
 	let content = '';
 
 	content += `/**\n`;
-	content += `\t* Lapikit\n`;
-	content += `\t* Library documentation: https://lapikit.dev\n`;
+	content += ` * Lapikit\n`;
+	content += ` * Library documentation: https://lapikit.dev\n`;
 	content += ` */\n\n`;
 
-	if (classic) {
-		content += `// Classic\n`;
+	if (adapterCSS === 'css') {
+		content += `// Styles\n`;
+		content += `import 'lapikit/styles';\n`;
 		content += `import 'lapikit/css';\n\n`;
 	}
 
 	content += `// Composables\n`;
-	content += `import { helloWorld } from 'lapikit';\n\n`;
+	content += `import createLapikit from 'lapikit';\n\n`;
 
 	content += `// https://lapikit.dev/docs/getting-started\n`;
-	content += `export default helloWorld();`;
+	content += `export default createLapikit({\n`;
+	content += `\tadapterCSS: "${adapterCSS}",\n`;
+	content += `\n});`;
 
 	return content;
 }

package/bin/prompts.js

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 import prompts from 'prompts';
+import { terminal } from './helper.js';
 
 export async function initPrompts() {
 	const { confirm } = await prompts({
 		type: 'toggle',
 		name: 'confirm',
-		message: 'Start install Lapikit on your app?',
+		message: 'Launch install Lapikit on your project?',
 		initial: true,
 		active: 'Yes',
 		inactive: 'No'
 	});
 
 	if (!confirm) {
-		console.log('❌ Installation canceled. See you soon.');
+		terminal('warn', `installation canceled.`);
 		process.exit(0);
 	}
 	// temps with legacy and new process install
@@ -70,7 +71,7 @@ export async function initPrompts() {
 				name: 'formatCSS',
 				message: 'What is your CSS format used on your app?',
 				choices: [
-					{ title: 'Basic (classic import)', value: 'global' },
+					{ title: 'Basic (classic import)', value: 'css' },
 					{
 						title: 'TailwindCSS (v4)',
 						value: 'tailwind-v4'
@@ -82,7 +83,7 @@ export async function initPrompts() {
 				]
 			},
 			{
-				type: (prev) => (prev !== 'global' ? 'text' : null),
+				type: (prev) => (prev !== 'css' ? 'text' : null),
 				name: 'pathCSS',
 				message: 'Where would you like to import the lapikit CSS files?',
 				initial: 'src/app.css',
@@ -91,8 +92,6 @@ export async function initPrompts() {
 			}
 		]);
 
-		console.log('response config', settings);
-
 		return {
 			...settings,
 			env: 'experimental'

package/dist/components/app/app.svelte

@@ -4,7 +4,8 @@
 		colorSchemeSystem,
 		modalOpen,
 		setOpenModal,
-		updateThemeStore
+		useColorScheme,
+		useTheme
 	} from '../../stores/index.js';
 	import type { Snippet } from 'svelte';
 	let { children }: { children: Snippet } = $props();
@@ -26,8 +27,12 @@
 			});
 
 		// local
-		const local = localStorage.getItem('@lapikit/theme');
-		if (local !== null) updateThemeStore(local as 'dark' | 'light' | 'system');
+		const localColorScheme = localStorage.getItem('@lapikit/color-scheme');
+		const localTheme = localStorage.getItem('@lapikit/theme');
+
+		// apply local settings
+		if (localColorScheme !== null) useColorScheme(localColorScheme as 'dark' | 'light' | 'system');
+		if (localTheme !== null) useTheme(localTheme as string);
 	});
 </script>
 

package/dist/components/chip/chip.css

@@ -20,7 +20,7 @@
 	text-decoration: none;
 }
 
-.kit-chip:not(div):not(span) {
+.kit-chip:not(div):not(span):not(.kit-chip--readonly) {
 	cursor: pointer;
 }
 
@@ -49,13 +49,13 @@
 	pointer-events: none;
 	border-radius: inherit;
 }
-.kit-chip:not(div):not(span):hover::after {
+.kit-chip:not(div):not(span):not(.kit-chip--readonly):hover::after {
 	opacity: 0.08;
 }
-.kit-chip:not(div):not(span):active::after {
+.kit-chip:not(div):not(span):not(.kit-chip--readonly):active::after {
 	opacity: 0.12;
 }
-.kit-chip:not(div):not(span):focus-visible::after {
+.kit-chip:not(div):not(span):not(.kit-chip--readonly):focus-visible::after {
 	opacity: 0.12;
 }
 

package/dist/components/chip/chip.svelte

@@ -37,6 +37,7 @@
 		rounded,
 		closable,
 		noRipple,
+		readonly = false,
 		...rest
 	}: ChipProps = $props();
 
@@ -44,7 +45,7 @@
 
 	$effect(() => {
 		const refProps = { ...rest };
-		if (refProps?.onclick) is = 'button';
+		if (refProps?.onclick && !readonly) is = 'button';
 	});
 </script>
 
@@ -68,6 +69,7 @@
 			disabled && 'kit-chip--disabled',
 			active && 'kit-chip--active',
 			loading && 'kit-chip--loading',
+			readonly && 'kit-chip--readonly',
 			rest.class
 		]}
 		tabindex={href && disabled ? -1 : 0}
@@ -77,7 +79,7 @@
 		type={href ? undefined : type}
 		use:ripple={{
 			component: 'chip',
-			disabled: noRipple || disabled || is === 'div' || is === 'span'
+			disabled: noRipple || readonly || disabled || is === 'div' || is === 'span'
 		}}
 		style:--base={assets.color(background)}
 		style:--on={assets.color(color)}
@@ -109,7 +111,7 @@
 			</div>
 		{/if}
 
-		{#if closable}
+		{#if closable && !readonly}
 			<button
 				class="kit-chip--close"
 				type="button"

package/dist/components/chip/types.d.ts

@@ -28,4 +28,5 @@ export interface ChipProps extends Component {
     label?: string;
     closable?: boolean;
     noRipple?: boolean;
+    readonly?: boolean;
 }

package/dist/components/dialog/dialog.css

@@ -60,7 +60,9 @@
 }
 
 .kit-dialog[breakpoint]kit-dialog--position-center {
-	margin: auto;
+	/* margin: auto; */
+	margin-top: auto;
+	margin-bottom: auto;
 }
 
 .kit-dialog[breakpoint]kit-dialog--size-xs {

package/dist/components/modal/modal.css

@@ -49,7 +49,6 @@
 	max-height: calc(100% - 3rem);
 	height: fit-content;
 	margin: 0 auto;
-	top: 50%;
 	left: 50%;
 	bottom: initial;
 	translate: var(--modal-translate-x) var(--modal-translate-y);
@@ -60,7 +59,6 @@
 	max-height: calc(100% - 3rem);
 	height: fit-content;
 	margin: 0 auto;
-	top: 50%;
 	left: 50%;
 	bottom: initial;
 	translate: var(--modal-translate-x) var(--modal-translate-y);
@@ -71,7 +69,6 @@
 	max-height: calc(100% - 3rem);
 	height: fit-content;
 	margin: 0 auto;
-	top: 50%;
 	left: 50%;
 	bottom: initial;
 	translate: var(--modal-translate-x) var(--modal-translate-y);
@@ -82,7 +79,6 @@
 	max-height: calc(100% - 3rem);
 	height: fit-content;
 	margin: 0 auto;
-	top: 50%;
 	left: 50%;
 	bottom: initial;
 	translate: var(--modal-translate-x) var(--modal-translate-y);
@@ -93,7 +89,6 @@
 	max-height: calc(100% - 3rem);
 	height: fit-content;
 	margin: 0 auto;
-	top: 50%;
 	left: 50%;
 	bottom: initial;
 	translate: var(--modal-translate-x) var(--modal-translate-y);
@@ -130,15 +125,21 @@
 /* position */
 .kit-modal [breakpoint]kit-modal-container--position-bottom {
 	--modal-translate-y: 0;
-	bottom: 0;
+	margin: auto;
 	top: initial;
+	bottom: 0;
 }
 
 .kit-modal [breakpoint]kit-modal-container--position-top {
 	--modal-translate-y: 0;
+	margin: auto;
 	top: 0;
+	bottom: initial;
 }
 
 .kit-modal [breakpoint]kit-modal-container--position-center {
+	--modal-translate-y: -50%;
 	margin: auto;
+	top: 50%;
+	bottom: initial;
 }

package/dist/index.d.ts

@@ -1 +1,27 @@
-export declare function helloWorld(): void;
+interface Lapikit {
+    adapterCSS: string;
+    breakpoints: {
+        devices: {
+            [key: string]: string;
+        };
+        thresholds: {
+            [key: string]: number | string;
+        };
+    };
+    theme: {
+        defaultTheme: string;
+        themes: {
+            [key: string]: {
+                dark: boolean;
+                colors: {
+                    [key: string]: string;
+                };
+                variables: {
+                    [key: string]: string;
+                };
+            };
+        };
+    };
+}
+declare function createLapikit(lapikit: Lapikit): void;
+export default createLapikit;

package/dist/index.js

@@ -1,4 +1,28 @@
-// Reexport your entry components here
-export function helloWorld() {
-    console.log('Hello world, this is lapikit!');
+import { deepMerge } from './internal/deepMerge.js';
+import { breakpoints } from './stores/breakpoints.js';
+import { get } from 'svelte/store';
+import { valueToPx } from './utils/convert.js';
+import { devices } from './stores/devices.js';
+function createLapikit(lapikit) {
+    console.log('Creating a new Lapikit instance...');
+    console.log('Options loaded:', lapikit);
+    if (lapikit?.breakpoints?.thresholds) {
+        const currentBreakpoints = get(breakpoints);
+        const breakpointMerged = deepMerge(currentBreakpoints, lapikit.breakpoints.thresholds);
+        const formattedBreakpoints = Object.fromEntries(Object.entries(breakpointMerged).map(([key, value]) => [key, valueToPx(value)]));
+        breakpoints.set(formattedBreakpoints);
+        console.log('Breakpoints found:', formattedBreakpoints);
+    }
+    if (lapikit?.breakpoints?.devices) {
+        const currentDevices = get(devices);
+        const currentBreakpoints = get(breakpoints);
+        const deviceMerged = deepMerge(currentDevices, lapikit.breakpoints.devices);
+        const formattedDevices = Object.fromEntries(Object.entries(deviceMerged).map(([key, deviceKey]) => {
+            const breakpointValue = currentBreakpoints[deviceKey];
+            return [key, valueToPx(breakpointValue)];
+        }));
+        devices.set(formattedDevices);
+        console.log('Devices found:', formattedDevices);
+    }
 }
+export default createLapikit;

package/dist/internal/deepMerge.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Recursively merges two objects together.
+ * Properties from the source object override those from the target object.
+ * Nested objects are merged recursively.
+ *
+ * @param target - The base object
+ * @param source - The source object to merge (can be null or undefined)
+ * @returns A new object containing the merge of both objects
+ *
+ * @example
+ * ```typescript
+ * const obj1 = { primary: { light: 'pink', medium: 'purple' } };
+ * const obj2 = { primary: { dark: 'red' } };
+ * const result = deepMerge(obj1, obj2);
+ * // Result: { primary: { light: 'pink', medium: 'purple', dark: 'red' } }
+ *
+ * // Works with null/undefined source
+ * const result2 = deepMerge(obj1, null);
+ * // Result: { primary: { light: 'pink', medium: 'purple' } }
+ * ```
+ */
+export declare function deepMerge<T extends Record<string, unknown>, U extends Record<string, unknown>>(target: T, source: U | null | undefined): T & U;
+/**
+ * Merges multiple objects together recursively.
+ *
+ * @param objects - The objects to merge (null and undefined values are ignored)
+ * @returns A new object containing the merge of all objects
+ *
+ * @example
+ * ```typescript
+ * const result = deepMergeMultiple(
+ *   { primary: { light: 'pink' } },
+ *   null,
+ *   { primary: { dark: 'red' } },
+ *   undefined,
+ *   { secondary: { light: 'blue' } }
+ * );
+ * // Result: {
+ * //   primary: { light: 'pink', dark: 'red' },
+ * //   secondary: { light: 'blue' }
+ * // }
+ * ```
+ */
+export declare function deepMergeMultiple(...objects: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;

package/dist/internal/deepMerge.js

@@ -0,0 +1,80 @@
+/**
+ * Checks if a value is a plain object (object literal)
+ */
+function isPlainObject(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        Object.prototype.toString.call(value) === '[object Object]');
+}
+/**
+ * Recursively merges two objects together.
+ * Properties from the source object override those from the target object.
+ * Nested objects are merged recursively.
+ *
+ * @param target - The base object
+ * @param source - The source object to merge (can be null or undefined)
+ * @returns A new object containing the merge of both objects
+ *
+ * @example
+ * ```typescript
+ * const obj1 = { primary: { light: 'pink', medium: 'purple' } };
+ * const obj2 = { primary: { dark: 'red' } };
+ * const result = deepMerge(obj1, obj2);
+ * // Result: { primary: { light: 'pink', medium: 'purple', dark: 'red' } }
+ *
+ * // Works with null/undefined source
+ * const result2 = deepMerge(obj1, null);
+ * // Result: { primary: { light: 'pink', medium: 'purple' } }
+ * ```
+ */
+export function deepMerge(target, source) {
+    // If source is null or undefined, return a copy of target
+    if (source == null) {
+        return { ...target };
+    }
+    // Create a copy of the target object to avoid mutations
+    const result = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            // If both values are plain objects, merge them recursively
+            if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                // Otherwise, the source value overrides the target value
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Merges multiple objects together recursively.
+ *
+ * @param objects - The objects to merge (null and undefined values are ignored)
+ * @returns A new object containing the merge of all objects
+ *
+ * @example
+ * ```typescript
+ * const result = deepMergeMultiple(
+ *   { primary: { light: 'pink' } },
+ *   null,
+ *   { primary: { dark: 'red' } },
+ *   undefined,
+ *   { secondary: { light: 'blue' } }
+ * );
+ * // Result: {
+ * //   primary: { light: 'pink', dark: 'red' },
+ * //   secondary: { light: 'blue' }
+ * // }
+ * ```
+ */
+export function deepMergeMultiple(...objects) {
+    return objects
+        .filter((obj) => obj != null)
+        .reduce((acc, obj) => {
+        return deepMerge(acc, obj);
+    }, {});
+}

package/dist/plugin/css.d.ts

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

package/dist/plugin/css.js

@@ -0,0 +1,76 @@
+import { deepMerge } from '../internal/deepMerge.js';
+import { preset } from './preset-v2.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fsPromises from 'fs/promises';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function css(configuration) {
+    console.log('VALUE configuration', configuration);
+    console.log('configuration?.theme?.themes', configuration?.theme?.themes);
+    // states
+    const defaultTheme = configuration?.theme?.defaultTheme || preset.theme.defaultTheme;
+    const themesMerged = deepMerge(preset.theme.themes, configuration?.theme?.themes || {});
+    let response = '';
+    console.log('VALUE themesMerged', themesMerged);
+    for (const [name, values] of Object.entries(themesMerged)) {
+        let css = defaultTheme === name ? `:root,\n.${name} {\n` : `.${name} {\n`;
+        // ref
+        const ref = values?.dark ? preset.theme.themes.dark : preset.theme.themes.light;
+        // colors
+        css += `  color-scheme: ${values?.dark ? 'dark' : 'light'};\n`;
+        for (const [varName, varValue] of Object.entries(deepMerge(ref.colors, values?.colors) || {})) {
+            css += `  --system-${varName}: ${varValue};\n`;
+        }
+        // console.log('VALUE', values, deepMerge(values?.variables, ref.variables));
+        // variables
+        for (const [name, varValue] of Object.entries(deepMerge(ref.variables, values?.variables) || {})) {
+            css += `  --kit-${name}: ${varValue};\n`;
+        }
+        css += '}\n';
+        // console.log(`Themes colors (${name}):`, css);
+        response += css;
+    }
+    // console.log('All themes CSS:', response);
+    //typography
+    // states
+    const defaultTypography = configuration?.typography?.defaultTypography || preset.typography.defaultTypography;
+    for (const [name, values] of Object.entries(deepMerge(preset.typography.fonts, configuration?.typography?.fonts || {}))) {
+        let css = '';
+        css += defaultTypography === name ? `:root {\n` : `.${name} {\n`;
+        // fonts
+        for (const [fontName, fontValue] of Object.entries(values || {})) {
+            css += `  --kit-font-${fontName}: ${parser(fontValue)};\n`;
+        }
+        css += '}\n';
+        response += css;
+    }
+    //styles
+    response += `:root {\n`;
+    for (const [name, values] of Object.entries(deepMerge(preset.styles, configuration?.styles || {}))) {
+        let css = '';
+        for (const [styleName, styleValue] of Object.entries(values || {})) {
+            console.log('VALUE', styleName, styleValue, typeof styleValue);
+            if (typeof styleValue === 'object') {
+                for (const [subStyleName, subStyleValue] of Object.entries(styleValue)) {
+                    css += `  --prism-${styleName}-${subStyleName}: ${parser(subStyleValue)};\n`;
+                }
+            }
+            else {
+                css += `  --prism-${styleName}: ${parser(styleValue)};\n`;
+            }
+        }
+        response += css;
+    }
+    response += '}\n';
+    fsPromises.writeFile(path.resolve(__dirname, '../colors.css'), response);
+}
+const parser = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value;
+};

package/dist/plugin/preset-v2.d.ts

@@ -0,0 +1,108 @@
+export declare const preset: {
+    breakpoints: {
+        devices: {
+            desktop: number;
+            tablet: number;
+            mobile: number;
+        };
+        thresholds: {
+            base: number;
+            xs: number;
+            sm: number;
+            md: number;
+            lg: number;
+            xl: number;
+            '2xl': number;
+            '3xl': number;
+        };
+    };
+    theme: {
+        defaultTheme: string;
+        themes: {
+            light: {
+                dark: boolean;
+                colors: {
+                    blue: string;
+                    green: string;
+                    red: string;
+                    yellow: string;
+                    orange: string;
+                    purple: string;
+                    pink: string;
+                    indigo: string;
+                    cyan: string;
+                    gray: string;
+                    'gray-2': string;
+                    'gray-3': string;
+                    'gray-4': string;
+                    'gray-5': string;
+                    'gray-6': string;
+                    background: string;
+                    'secondary-background': string;
+                    'tertiary-background': string;
+                    label: string;
+                    'secondary-label': string;
+                };
+                variables: {
+                    info: string;
+                    success: string;
+                    error: string;
+                    warning: string;
+                };
+            };
+            dark: {
+                dark: boolean;
+                colors: {
+                    blue: string;
+                    green: string;
+                    red: string;
+                    yellow: string;
+                    orange: string;
+                    purple: string;
+                    pink: string;
+                    indigo: string;
+                    cyan: string;
+                    gray: string;
+                    'gray-2': string;
+                    'gray-3': string;
+                    'gray-4': string;
+                    'gray-5': string;
+                    'gray-6': string;
+                    background: string;
+                    'secondary-background': string;
+                    'tertiary-background': string;
+                    label: string;
+                    'secondary-label': string;
+                };
+                variables: {
+                    info: string;
+                    success: string;
+                    error: string;
+                    warning: string;
+                };
+            };
+        };
+    };
+    typography: {
+        defaultTypography: string;
+        fonts: {
+            default: {
+                sans: string[];
+                mono: string[];
+                serif: string[];
+            };
+        };
+    };
+    styles: {
+        spacing: string;
+        shape: {
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+            '2xl': string;
+            '3xl': string;
+            full: string;
+        };
+    };
+};

package/dist/plugin/preset-v2.js

@@ -0,0 +1,126 @@
+const variables = {
+    info: 'var(--system-blue)',
+    success: 'var(--system-green)',
+    error: 'var(--system-red)',
+    warning: 'var(--system-yellow)'
+};
+export const preset = {
+    breakpoints: {
+        devices: {
+            desktop: 1024, //64rem (lg)
+            tablet: 768, //48rem (md)
+            mobile: 375 //28rem (sm)
+        },
+        thresholds: {
+            base: 0, // 0px
+            xs: 448, //28rem
+            sm: 640, //40rem
+            md: 768, //48rem
+            lg: 1024, //64rem
+            xl: 1280, //80rem
+            '2xl': 1536, //96rem
+            '3xl': 1792 //112rem
+        }
+    },
+    theme: {
+        defaultTheme: 'light',
+        themes: {
+            light: {
+                dark: false,
+                colors: {
+                    blue: '#007AFF',
+                    green: '#34C759',
+                    red: '#FF3B30',
+                    yellow: '#FFCC00',
+                    orange: '#FF9500',
+                    purple: '#AF52DE',
+                    pink: '#FF2D55',
+                    indigo: '#5856D6',
+                    cyan: '#5AC8FA',
+                    gray: '#8E8E93',
+                    'gray-2': '#AEAEB2',
+                    'gray-3': '#C7C7CC',
+                    'gray-4': '#D1D1D6',
+                    'gray-5': '#E5E5EA',
+                    'gray-6': '#F2F2F7',
+                    background: '#FFFFFF',
+                    'secondary-background': '#F2F2F7',
+                    'tertiary-background': '#EFEFF4',
+                    label: '#000000',
+                    'secondary-label': 'rgba(60,60,67,0.6)'
+                },
+                variables: variables
+            },
+            dark: {
+                dark: true,
+                colors: {
+                    blue: '#0A84FF',
+                    green: '#30D158',
+                    red: '#FF453A',
+                    yellow: '#FFD60A',
+                    orange: '#FF9F0A',
+                    purple: '#BF5AF2',
+                    pink: '#FF375F',
+                    indigo: '#5E5CE6',
+                    cyan: '#64D2FF',
+                    gray: '#8E8E93',
+                    'gray-2': '#636366',
+                    'gray-3': '#48484A',
+                    'gray-4': '#3A3A3C',
+                    'gray-5': '#2C2C2E',
+                    'gray-6': '#1C1C1E',
+                    background: '#000000',
+                    'secondary-background': '#1C1C1E',
+                    'tertiary-background': '#2C2C2E',
+                    label: '#FFFFFF',
+                    'secondary-label': 'rgba(235,235,245,0.6)'
+                },
+                variables: variables
+            }
+        }
+    },
+    typography: {
+        defaultTypography: 'default',
+        fonts: {
+            default: {
+                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']
+            }
+        }
+    },
+    styles: {
+        spacing: '0.125rem', // 2px
+        shape: {
+            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
+        }
+    }
+};

package/dist/plugin/vitejs.d.ts

@@ -1,6 +1,10 @@
 import type { ViteDevServer } from 'vite';
-export declare function lapikit(): Promise<{
+type Lapikit = {
+    config?: string;
+};
+export declare function lapikit({ config }?: Lapikit): Promise<{
     name: string;
     configResolved(): Promise<void>;
     configureServer(server: ViteDevServer): Promise<void>;
 }>;
+export {};

package/dist/plugin/vitejs.js

@@ -2,12 +2,41 @@ 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() {
+import path from 'path';
+import fs from 'fs';
+import { css } from './css.js';
+const app = process.cwd();
+async function getLapikitConfig(filePath) {
+    const pathConfig = path.resolve(app, filePath);
+    if (!fs.existsSync(pathConfig))
+        process.exit(1);
+    const code = fs.readFileSync(pathConfig, 'utf-8');
+    const match = code.match(/createLapikit\s*\(\s*({[\s\S]*?})\s*\)/);
+    let options = {};
+    if (match && match[1]) {
+        try {
+            options = new Function('return ' + match[1])();
+        }
+        catch (e) {
+            console.error('Error parsing lapikit config:', e);
+        }
+    }
+    else {
+        console.error('Lapikit not found');
+    }
+    return options;
+}
+export async function lapikit({ config } = {}) {
+    if (config) {
+        const value = await getLapikitConfig(config);
+        // console.log(value);
+        await css(value);
+    }
     return {
         name: 'lapikit/vite.js',
         async configResolved() {
-            const config = await importer();
-            const result = await parseConfig(config);
+            const importedConfig = await importer();
+            const result = await parseConfig(importedConfig);
             await processCSS(result);
             terminal('info', 'lapikit is up!');
         },

package/dist/stores/breakpoints.d.ts

@@ -0,0 +1,6 @@
+import { type Writable } from 'svelte/store';
+type Breakpoints = {
+    [key: string]: number;
+};
+export declare const breakpoints: Writable<Breakpoints>;
+export {};

package/dist/stores/breakpoints.js

@@ -0,0 +1,14 @@
+// store breakpoints and thresholds
+import { writable } from 'svelte/store';
+// presets
+const ref = {
+    base: 0, // 0px
+    xs: 448, //28rem
+    sm: 640, //40rem
+    md: 768, //48rem
+    lg: 1024, //64rem
+    xl: 1280, //80rem
+    '2xl': 1536, //96rem
+    '3xl': 1792 //112rem
+};
+export const breakpoints = writable(ref);

package/dist/stores/components.d.ts

@@ -0,0 +1,8 @@
+import { type Writable } from 'svelte/store';
+type ModalState = boolean | 'persistent';
+export declare const modalOpen: Writable<ModalState>;
+export declare const modalStack: Writable<string[]>;
+export declare function setOpenModal(state: boolean | 'persistent'): void;
+export declare const pushModal: (id: string) => void;
+export declare const popModal: (id: string) => void;
+export {};

package/dist/stores/components.js

@@ -0,0 +1,26 @@
+import { disabledScroll } from '../internal/scroll.js';
+import { writable } from 'svelte/store';
+// presets
+const refModal = false;
+// states
+export const modalOpen = writable(refModal);
+export const modalStack = writable([]);
+export function setOpenModal(state) {
+    modalOpen.set(state);
+}
+export const pushModal = (id) => {
+    modalStack.update((stack) => {
+        let values = stack;
+        if (!stack.includes(id))
+            values = [...stack, id];
+        disabledScroll(values.length !== 0 ? true : false);
+        return values;
+    });
+};
+export const popModal = (id) => {
+    modalStack.update((stack) => {
+        const newStack = stack.filter((m) => m !== id);
+        disabledScroll(newStack.length !== 0 ? true : false);
+        return newStack.length === 0 ? [] : newStack;
+    });
+};

package/dist/stores/devices.d.ts

@@ -0,0 +1,6 @@
+import { type Writable } from 'svelte/store';
+type Devices = {
+    [key: string]: number;
+};
+export declare const devices: Writable<Devices>;
+export {};

package/dist/stores/devices.js

@@ -0,0 +1,9 @@
+// store devices
+import { writable } from 'svelte/store';
+// presets
+const ref = {
+    desktop: 1024, //64rem (lg)
+    tablet: 768, //48rem (md)
+    mobile: 375 //28rem (sm)
+};
+export const devices = writable(ref);

package/dist/stores/index.d.ts

@@ -1,10 +1,4 @@
-import { type Writable } from 'svelte/store';
-export declare const colorScheme: Writable<'system' | 'dark' | 'light'>;
-export declare const colorSchemeSystem: Writable<'dark' | 'light'>;
-export declare const modalOpen: Writable<boolean | 'persistent'>;
-export declare const modalStack: Writable<string[]>;
-export declare function updateThemeStore(update: 'system' | 'dark' | 'light'): void;
-export declare function setColorScheme(scheme: 'system' | 'dark' | 'light'): void;
-export declare function setOpenModal(state: boolean | 'persistent'): void;
-export declare const pushModal: (id: string) => void;
-export declare const popModal: (id: string) => void;
+export * from './breakpoints.js';
+export * from './devices.js';
+export * from './themes.js';
+export * from './components.js';

package/dist/stores/index.js

@@ -1,47 +1,4 @@
-import { disabledScroll } from '../internal/scroll.js';
-import { writable } from 'svelte/store';
-// states
-const colorScheme_default = 'system';
-const modalOpen_default = false;
-const isBrowser = typeof window !== 'undefined';
-export const colorScheme = writable(colorScheme_default);
-export const colorSchemeSystem = writable('light');
-export const modalOpen = writable(modalOpen_default);
-export const modalStack = writable([]);
-export function updateThemeStore(update) {
-    colorScheme.update(() => {
-        if (isBrowser) {
-            const ref = document.documentElement.classList;
-            if (update === 'system')
-                ref.remove('light', 'dark');
-            else {
-                ref.remove(update === 'dark' ? 'light' : 'dark');
-                ref.add(update === 'dark' ? 'dark' : 'light');
-            }
-            localStorage.setItem('@lapikit/theme', update);
-        }
-        return update;
-    });
-}
-export function setColorScheme(scheme) {
-    updateThemeStore(scheme);
-}
-export function setOpenModal(state) {
-    modalOpen.set(state);
-}
-export const pushModal = (id) => {
-    modalStack.update((stack) => {
-        let values = stack;
-        if (!stack.includes(id))
-            values = [...stack, id];
-        disabledScroll(values.length !== 0 ? true : false);
-        return values;
-    });
-};
-export const popModal = (id) => {
-    modalStack.update((stack) => {
-        const newStack = stack.filter((m) => m !== id);
-        disabledScroll(newStack.length !== 0 ? true : false);
-        return newStack.length === 0 ? [] : newStack;
-    });
-};
+export * from './breakpoints.js';
+export * from './devices.js';
+export * from './themes.js';
+export * from './components.js';

package/dist/stores/themes.d.ts

@@ -0,0 +1,8 @@
+import { type Writable } from 'svelte/store';
+type PreferColorScheme = 'system' | 'dark' | 'light';
+export declare const colorScheme: Writable<PreferColorScheme>;
+export declare const colorSchemeSystem: Writable<'dark' | 'light'>;
+export declare const theme: Writable<string>;
+export declare function useColorScheme(scheme: PreferColorScheme, key?: string): void;
+export declare function useTheme(name: string, key?: string): void;
+export {};

package/dist/stores/themes.js

@@ -0,0 +1,34 @@
+import { writable } from 'svelte/store';
+// presets
+const colorSchemeRef = 'system';
+const themeRef = 'lapikit';
+// states
+const isBrowser = typeof window !== 'undefined';
+export const colorScheme = writable(colorSchemeRef);
+export const colorSchemeSystem = writable('light');
+export const theme = writable(themeRef);
+export function useColorScheme(scheme, key = '@lapikit/color-scheme') {
+    colorScheme.update(() => {
+        if (isBrowser) {
+            const ref = document.documentElement.classList;
+            if (scheme === 'system')
+                ref.remove('light', 'dark');
+            else {
+                ref.remove(scheme === 'dark' ? 'light' : 'dark');
+                ref.add(scheme === 'dark' ? 'dark' : 'light');
+            }
+            localStorage.setItem(key, scheme);
+        }
+        return scheme;
+    });
+}
+export function useTheme(name, key = '@lapikit/theme') {
+    theme.update(() => {
+        if (isBrowser) {
+            const html = document.documentElement;
+            html.setAttribute('data-theme', name);
+            localStorage.setItem(key, name);
+        }
+        return name;
+    });
+}

package/dist/utils/convert.d.ts

@@ -0,0 +1 @@
+export declare function valueToPx(value: string | number): number;

package/dist/utils/convert.js

@@ -0,0 +1,17 @@
+export function valueToPx(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        if (value.endsWith('rem')) {
+            return parseFloat(value) * 16;
+        }
+        if (value.endsWith('em')) {
+            return parseFloat(value) * 16;
+        }
+        if (value.endsWith('px')) {
+            return parseFloat(value);
+        }
+        return parseFloat(value);
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lapikit",
-	"version": "0.0.0-insiders.bd609af",
+	"version": "0.0.0-insiders.c3399e0",
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"
@@ -59,7 +59,8 @@
 		"./actions": {
 			"default": "./dist/actions/index.js"
 		},
-		"./css": "./dist/styles.css"
+		"./css": "./dist/styles.css",
+		"./styles": "./dist/colors.css"
 	},
 	"peerDependencies": {
 		"svelte": "^5.0.0"