lapikit 0.0.0-insiders.438d572 → 0.0.0-insiders.4648468

package/bin/configuration.js

@@ -0,0 +1,298 @@
+#!/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) {
+	const routesPath = path.join(projectPath, 'src', 'routes');
+
+	try {
+		await fs.access(routesPath);
+	} catch {
+		terminal('error', `Lapikit cannot find the routes/ directory.`);
+		// throw new Error('Lapikit cannot find the routes/ directory.');
+	}
+
+	const layoutFile = path.join(routesPath, '+layout.svelte');
+	try {
+		await fs.access(layoutFile);
+		return layoutFile;
+	} catch {
+		// +layout.svelte not found in routes/
+	}
+
+	const pageFile = path.join(routesPath, '+page.svelte');
+	try {
+		await fs.access(pageFile);
+		return pageFile;
+	} catch {
+		// +page.svelte not found in routes/
+	}
+
+	try {
+		const entries = await fs.readdir(routesPath, { withFileTypes: true });
+		const subDirectories = entries.filter((entry) => entry.isDirectory());
+
+		for (const dir of subDirectories) {
+			const subDirPath = path.join(routesPath, dir.name);
+
+			const subLayoutFile = path.join(subDirPath, '+layout.svelte');
+			try {
+				await fs.access(subLayoutFile);
+				return subLayoutFile;
+			} catch {
+				// +layout.svelte not found in subdirectory
+			}
+
+			const subPageFile = path.join(subDirPath, '+page.svelte');
+			try {
+				await fs.access(subPageFile);
+				return subPageFile;
+			} catch {
+				// +page.svelte not found in subdirectory
+			}
+		}
+	} catch {
+		// Error reading routes directory
+	}
+
+	throw new Error('Not found +layout or +page main on your project.');
+}
+
+async function addImportToReferenceFile(targetFile, referenceFile) {
+	try {
+		const content = await fs.readFile(referenceFile, 'utf-8');
+		const relativePath = path.relative(path.dirname(referenceFile), targetFile);
+		const importStatement = `import "${relativePath.startsWith('.') ? relativePath : './' + relativePath}";\n`;
+
+		if (content.includes(`import "${relativePath}"`)) {
+			terminal('info', `Import statement already exists in ${referenceFile}`);
+			return;
+		}
+
+		const lines = content.split('\n');
+		let insertIndex = -1;
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+			if (line.startsWith('<script>') || line.startsWith('<script lang="ts">')) {
+				insertIndex = i + 1;
+				break;
+			}
+		}
+
+		if (insertIndex === -1) {
+			throw new Error(`No found balise <script> ou <script lang="ts"> ${referenceFile}`);
+		}
+
+		let finalInsertIndex = insertIndex;
+		for (let i = insertIndex; i < lines.length; i++) {
+			const line = lines[i].trim();
+
+			if (line === '</script>') {
+				break;
+			}
+
+			if (line === '' || line.startsWith('import ') || line.startsWith('//')) {
+				finalInsertIndex = i + 1;
+			} else {
+				break;
+			}
+		}
+
+		lines.splice(finalInsertIndex, 0, `\t${importStatement.trim()}`);
+		const newContent = lines.join('\n');
+
+		await fs.writeFile(referenceFile, newContent);
+		terminal('info', `Import has been added to ${referenceFile}`);
+	} catch (error) {
+		terminal('error', `Error adding import: ${error.message}`);
+		throw error;
+	}
+}
+
+async function findViteConfigFile(projectPath, typescript) {
+	const ext = typescript ? 'ts' : 'js';
+	const viteConfigFile = path.join(projectPath, `vite.config.${ext}`);
+
+	try {
+		await fs.access(viteConfigFile);
+		return viteConfigFile;
+	} catch {
+		// Try the other extension if the preferred one doesn't exist
+		const alternativeExt = typescript ? 'js' : 'ts';
+		const alternativeFile = path.join(projectPath, `vite.config.${alternativeExt}`);
+
+		try {
+			await fs.access(alternativeFile);
+			return alternativeFile;
+		} catch {
+			throw new Error(`No vite.config.js or vite.config.ts file found in ${projectPath}`);
+		}
+	}
+}
+
+async function addLapikitToViteConfig(viteConfigFile) {
+	try {
+		const content = await fs.readFile(viteConfigFile, 'utf-8');
+		const lapikitImport = `import { lapikit } from 'lapikit/vite';`;
+
+		// Check if lapikit import already exists
+		if (content.includes(lapikitImport) || content.includes(`from 'lapikit/vite'`)) {
+			terminal('info', `Lapikit import already exists in ${viteConfigFile}`);
+			return;
+		}
+
+		const lines = content.split('\n');
+		let importInsertIndex = -1;
+		let pluginAdded = false;
+
+		// Find where to insert the import (after other imports)
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+
+			if (line.startsWith('import ') && !line.includes('type ')) {
+				importInsertIndex = i + 1;
+			} else if (
+				line === '' &&
+				importInsertIndex !== -1 &&
+				lines[i + 1] &&
+				!lines[i + 1].trim().startsWith('import ')
+			) {
+				importInsertIndex = i;
+				break;
+			}
+		}
+
+		// If no imports found, insert at the beginning
+		if (importInsertIndex === -1) {
+			importInsertIndex = 0;
+		}
+
+		// Insert the lapikit import
+		lines.splice(importInsertIndex, 0, lapikitImport);
+
+		// Find and update the plugins array
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+
+			if (line.includes('plugins:') && line.includes('[') && line.includes(']')) {
+				// Single line plugins array
+				if (line.includes('sveltekit()')) {
+					const pluginMatch = line.match(/plugins:\s*\[(.*)\]/);
+					if (pluginMatch) {
+						const pluginsContent = pluginMatch[1];
+						if (!pluginsContent.includes('lapikit()')) {
+							const newPluginsContent = pluginsContent.replace(
+								/sveltekit\(\)/,
+								'sveltekit(), lapikit()'
+							);
+							lines[i] = line.replace(pluginsContent, newPluginsContent);
+							pluginAdded = true;
+						}
+					}
+				}
+				break;
+			} else if (line.includes('plugins:') && line.includes('[') && !line.includes(']')) {
+				// Multi-line plugins array start
+				for (let j = i; j < lines.length; j++) {
+					const pluginLine = lines[j].trim();
+
+					if (pluginLine.includes('sveltekit()') && !pluginAdded) {
+						// 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()')) {
+								hasLapikit = true;
+								break;
+							}
+						}
+
+						if (!hasLapikit) {
+							// Add lapikit() after sveltekit()
+							if (pluginLine.includes(',')) {
+								lines[j] = lines[j].replace('sveltekit()', 'sveltekit(), lapikit()');
+							} else {
+								lines[j] = lines[j].replace('sveltekit()', 'sveltekit(),');
+								// Insert lapikit() on the next line with proper indentation
+								const indentation = lines[j].match(/^\s*/)[0];
+								lines.splice(j + 1, 0, `${indentation}lapikit()`);
+							}
+							pluginAdded = true;
+						}
+						break;
+					}
+
+					if (pluginLine.includes(']')) {
+						break;
+					}
+				}
+				break;
+			}
+		}
+
+		if (!pluginAdded) {
+			terminal('warn', `Could not find sveltekit() in plugins array to add lapikit() after it`);
+		}
+
+		const newContent = lines.join('\n');
+		await fs.writeFile(viteConfigFile, newContent);
+		terminal('info', `Lapikit import and plugin added to ${viteConfigFile}`);
+	} catch (error) {
+		terminal('error', `Error adding lapikit to vite config: ${error.message}`);
+		throw error;
+	}
+}
+
+export async function initConfiguration(options) {
+	const { typescript, pathConfig, formatCSS } = options;
+	const ext = typescript ? 'ts' : 'js';
+	const targetDir = path.resolve(process.cwd(), pathConfig);
+	const targetFile = path.join(targetDir, `lapikit.${ext}`);
+
+	await fs.mkdir(targetDir, { recursive: true });
+
+	let fileCreated = false;
+
+	// Create Lapikit config
+	try {
+		await fs.access(targetFile);
+		terminal('info', `File ${targetFile} already exists.`);
+	} catch {
+		terminal('info', `Creating file: ${targetFile}`);
+		const content = presets({
+			adapterCSS: formatCSS
+		});
+		await fs.writeFile(targetFile, content);
+		terminal('info', `File created: ${targetFile}`);
+		fileCreated = true;
+	}
+
+	// Add Import Lapikit plugin
+	try {
+		const referenceFile = await findReferenceFile(process.cwd());
+		await addImportToReferenceFile(targetFile, referenceFile);
+	} catch (error) {
+		terminal('error', `Error adding import: ${error.message}`);
+
+		if (fileCreated) {
+			try {
+				await fs.unlink(targetFile);
+				terminal('info', `File ${targetFile} deleted due to error.`);
+			} catch {
+				// Ignore deletion error
+			}
+		}
+		throw error;
+	}
+
+	// Add lapikit to vite.config file
+	try {
+		const viteConfigFile = await findViteConfigFile(process.cwd(), typescript);
+		await addLapikitToViteConfig(viteConfigFile);
+	} catch (error) {
+		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

@@ -1,41 +1,41 @@
 #!/usr/bin/env node
-import prompts from 'prompts';
+import { initConfiguration } from './configuration.js';
+import { ansi, terminal } from './helper.js';
+import { legacyConfiguration } from './legacy.js';
+import { initPrompts } from './prompts.js';
 
-async function main() {
-	console.log('🚀 Welcome in Lapikit !');
+async function run() {
+	console.log('  _                 _ _    _ _   ');
+	console.log(' | |               (_) |  (_) |  ');
+	console.log(' | |     __ _ _ __  _| | ___| |_ ');
+	console.log(" | |    / _` | '_ \\| | |/ / | __|");
+	console.log(' | |___| (_| | |_) | |   <| | |_ ');
+	console.log(' |______\\__,_| .__/|_|_|\\_\\_|\\__|');
+	console.log('             | |                 ');
+	console.log('             |_|                 \n');
 
-	const response = await prompts([
-		{
-			type: 'text',
-			name: 'projectName',
-			message: 'Project name ?',
-			initial: 'lapikit-app'
-		},
-		{
-			type: 'select',
-			name: 'theme',
-			message: 'Choice theme :',
-			choices: [
-				{ title: 'Light', value: 'light' },
-				{ title: 'Dark', value: 'dark' },
-				{ title: 'Auto', value: 'auto' }
-			],
-			initial: 0
-		},
-		{
-			type: 'toggle',
-			name: 'typescript',
-			message: 'Use TypeScript ?',
-			initial: true,
-			active: 'Oui',
-			inactive: 'Non'
-		}
-	]);
+	terminal('none', `${ansi.bold.blue('Lapikit')} - Component Library for Svelte\n\n`);
 
-	console.log('\n Resume :');
-	console.log(JSON.stringify(response, null, 2));
+	const promptsConfig = await initPrompts();
 
-	console.log(`Config : ${configFile}`);
+	if (promptsConfig.env === 'current') {
+		await legacyConfiguration(promptsConfig);
+	}
+
+	if (promptsConfig.env === 'experimental') {
+		terminal('warn', `Experimental mode is not yet implemented.`);
+		await initConfiguration(promptsConfig);
+	}
 }
 
-main();
+run()
+	.then(() => {
+		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) => {
+		terminal('error', `Error: ${error}`);
+		process.exit(1);
+	});

package/bin/legacy.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { promises as fs } from 'fs';
+import path from 'path';
+import { preset } from './modules/preset.js';
+import { ansi, terminal, envTypescript } from './helper.js';
+import { adapterCSSConfig, adapterViteConfig } from './modules/adapter.js';
+
+export async function legacyConfiguration(options) {
+	const typescriptEnabled = envTypescript();
+	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://lapikit.dev/docs/getting-started for more information`
+		);
+	}
+
+	await adapterViteConfig(typescriptEnabled);
+	await adapterCSSConfig(options);
+
+	terminal(
+		'info',
+		`${ansi.bold.blue('Thank to use lapikit, discover all posibility with lapikit on https://lapikit.dev')}\n\n`
+	);
+
+	console.log('Website: https://lapikit.dev');
+	console.log('Github: https://github.com/nycolaide/lapikit');
+	console.log('Support the developement: https://buymeacoffee.com/nycolaide');
+}

package/bin/modules/adapter.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import { getCssPathFromArgs, terminal } from '../helper.js';
+import { terminal } from '../helper.js';
 
 const importLapikitVite = `import { lapikit } from 'lapikit/vite';`;
 const importLapikitCss = `@import 'lapikit/css';`;
@@ -33,8 +33,8 @@ export async function adapterViteConfig(typescript) {
 	}
 }
 
-export async function adapterCSSConfig() {
-	const cssPath = getCssPathFromArgs();
+export async function adapterCSSConfig(options) {
+	const cssPath = options?.pathCSS || 'src/app.css';
 	const resolvedPath = path.resolve(process.cwd(), cssPath);
 	try {
 		await fs.access(resolvedPath);

package/bin/presets.js

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

package/bin/prompts.js

@@ -0,0 +1,100 @@
+#!/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: 'Launch install Lapikit on your project?',
+		initial: true,
+		active: 'Yes',
+		inactive: 'No'
+	});
+
+	if (!confirm) {
+		terminal('warn', `installation canceled.`);
+		process.exit(0);
+	}
+	// temps with legacy and new process install
+	const { type } = await prompts({
+		type: 'select',
+		name: 'type',
+		message: 'Select installation type:',
+		choices: [
+			{ title: 'Classic install with lapikit.config.js', value: 'current' },
+			{
+				title: 'Preview install with new plugin/lapikit.(js|ts) <experimental>',
+				value: 'experimental'
+			}
+		]
+	});
+
+	if (type === 'current') {
+		// Classic install
+		const settings = await prompts([
+			{
+				type: 'text',
+				name: 'pathCSS',
+				message: 'Where would you like to import the lapikit CSS files?',
+				initial: 'src/app.css',
+				validate: (value) =>
+					value.startsWith('src/') ? true : 'Please provide a valid path starting with src/'
+			}
+		]);
+
+		return {
+			...settings,
+			env: 'current'
+		};
+	} else if (type === 'experimental') {
+		// Preview install
+		let settings = await prompts([
+			{
+				type: 'text',
+				name: 'pathConfig',
+				message: 'Where would you like to install the lapikit configuration files?',
+				initial: 'src/plugins',
+				validate: (value) =>
+					value.startsWith('src/') ? true : 'Please provide a valid path starting with src/'
+			},
+			{
+				type: 'toggle',
+				name: 'typescript',
+				message: 'Use TypeScript?',
+				initial: true,
+				active: 'Yes',
+				inactive: 'No'
+			},
+			{
+				type: 'select',
+				name: 'formatCSS',
+				message: 'What is your CSS format used on your app?',
+				choices: [
+					{ title: 'Basic (classic import)', value: 'css' },
+					{
+						title: 'TailwindCSS (v4)',
+						value: 'tailwind-v4'
+					},
+					{
+						title: 'UnoCSS',
+						value: 'unocss'
+					}
+				]
+			},
+			{
+				type: (prev) => (prev !== 'css' ? 'text' : null),
+				name: 'pathCSS',
+				message: 'Where would you like to import the lapikit CSS files?',
+				initial: 'src/app.css',
+				validate: (value) =>
+					value.startsWith('src/') ? true : 'Please provide a valid path starting with src/'
+			}
+		]);
+
+		return {
+			...settings,
+			env: 'experimental'
+		};
+	}
+}

package/dist/actions/index.d.ts

@@ -1 +1,2 @@
 export * from '../components/accordion/accordion.svelte.js';
+export * from '../internal/mediaQueries.js';

package/dist/actions/index.js

@@ -1 +1,2 @@
 export * from '../components/accordion/accordion.svelte.js';
+export * from '../internal/mediaQueries.js';

package/dist/components/app/app.svelte

@@ -4,11 +4,21 @@
 		colorSchemeSystem,
 		modalOpen,
 		setOpenModal,
-		updateThemeStore
+		updateThemeStore,
+		viewportWidth
 	} from '../../stores/index.js';
 	import type { Snippet } from 'svelte';
 	let { children }: { children: Snippet } = $props();
 
+	// states
+	let innerWidth = $state(0);
+
+	$effect(() => {
+		if (BROWSER) {
+			viewportWidth.set(innerWidth);
+		}
+	});
+
 	$effect.pre(() => {
 		if (!BROWSER) return;
 		// system
@@ -31,6 +41,8 @@
 	});
 </script>
 
+<svelte:window bind:innerWidth />
+
 {@render children?.()}
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->

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/internal/mediaQueries.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Non-reactive media queries function
+ * Use this in JavaScript code when you need a one-time check
+ * @param {...Array<["min"|"max", string]>} args - ex: [ ["min", "xs"], ["max", "lg"] ]
+ * @returns {boolean}
+ */
+export declare function mediaQueries(...args: Array<['min' | 'max', string]> | ['min' | 'max', string]): boolean;
+/**
+ * Reactive media queries that returns a store
+ * Use this in Svelte templates for automatic reactivity
+ * @param {...Array<["min"|"max", string]>} args - ex: [ ["min", "xs"], ["max", "lg"] ]
+ * @returns {import('svelte/store').Readable<boolean>}
+ */
+export declare function mediaQueriesReactive(...args: Array<['min' | 'max', string]> | ['min' | 'max', string]): import("svelte/store").Readable<boolean>;
+/**
+ * Convenient function for direct use in Svelte templates
+ * Returns a readable store that updates automatically
+ * Usage: $mediaQuery(['min', 'md']) in template
+ */
+export declare const mediaQuery: typeof mediaQueriesReactive;

package/dist/internal/mediaQueries.js

@@ -0,0 +1,88 @@
+import { get, derived } from 'svelte/store';
+import { breakpoints } from '../stores/breakpoints.js';
+import { viewportWidth } from '../stores/viewports.js';
+// Converts rem/em/px to number of pixels
+function toPx(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;
+}
+/**
+ * Non-reactive media queries function
+ * Use this in JavaScript code when you need a one-time check
+ * @param {...Array<["min"|"max", string]>} args - ex: [ ["min", "xs"], ["max", "lg"] ]
+ * @returns {boolean}
+ */
+export function mediaQueries(...args) {
+    const bp = get(breakpoints);
+    const width = get(viewportWidth) || (typeof window !== 'undefined' ? window.innerWidth : 0);
+    // Parse arguments
+    let queries = [];
+    if (Array.isArray(args[0]) && typeof args[0][0] === 'string') {
+        queries = args;
+    }
+    else if (typeof args[0] === 'string') {
+        queries = [args];
+    }
+    let result = true;
+    for (const [type, key] of queries) {
+        const value = bp[key];
+        const px = toPx(value);
+        if (type === 'min') {
+            result = result && width >= px;
+        }
+        else if (type === 'max') {
+            result = result && width <= px;
+        }
+    }
+    return result;
+}
+/**
+ * Reactive media queries that returns a store
+ * Use this in Svelte templates for automatic reactivity
+ * @param {...Array<["min"|"max", string]>} args - ex: [ ["min", "xs"], ["max", "lg"] ]
+ * @returns {import('svelte/store').Readable<boolean>}
+ */
+export function mediaQueriesReactive(...args) {
+    return derived([breakpoints, viewportWidth], ([$breakpoints, $viewportWidth]) => {
+        const width = $viewportWidth || (typeof window !== 'undefined' ? window.innerWidth : 0);
+        // Parse arguments same way as non-reactive version
+        let queries = [];
+        if (Array.isArray(args[0]) && typeof args[0][0] === 'string') {
+            queries = args;
+        }
+        else if (typeof args[0] === 'string') {
+            queries = [args];
+        }
+        let result = true;
+        for (const [type, key] of queries) {
+            const value = $breakpoints[key];
+            const px = toPx(value);
+            if (type === 'min') {
+                result = result && width >= px;
+            }
+            else if (type === 'max') {
+                result = result && width <= px;
+            }
+        }
+        return result;
+    });
+}
+/**
+ * Convenient function for direct use in Svelte templates
+ * Returns a readable store that updates automatically
+ * Usage: $mediaQuery(['min', 'md']) in template
+ */
+export const mediaQuery = mediaQueriesReactive;

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/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

@@ -8,3 +8,7 @@ export declare function setColorScheme(scheme: 'system' | 'dark' | 'light'): voi
 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 './viewports.js';
+export * from './devices.js';
+export { mediaQueries, mediaQueriesReactive, mediaQuery } from '../internal/mediaQueries.js';

package/dist/stores/index.js

@@ -45,3 +45,7 @@ export const popModal = (id) => {
         return newStack.length === 0 ? [] : newStack;
     });
 };
+export * from './breakpoints.js';
+export * from './viewports.js';
+export * from './devices.js';
+export { mediaQueries, mediaQueriesReactive, mediaQuery } from '../internal/mediaQueries.js';

package/dist/stores/viewports.d.ts

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare const viewportWidth: Writable<number>;

package/dist/stores/viewports.js

@@ -0,0 +1,5 @@
+// store viewport and screen dimensions
+import { writable } from 'svelte/store';
+// presets
+const refWidth = 0;
+export const viewportWidth = writable(refWidth);

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.438d572",
+	"version": "0.0.0-insiders.4648468",
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"