lapikit 0.0.0-insiders.d5e2672 → 0.0.0-insiders.d6bc7da

package/README.md

@@ -1 +1,7 @@
-# Lapikit
+<img alt="Lapikit Logo" src="https://raw.githubusercontent.com/nycolaide/lapikit/main/apps/website/src/lib/images/lapinosaure/lapinosaure.webp" width="75">
+
+[![][logo]](https://lapikit.dev)
+
+# Lapikit - Svelte components library
+
+[logo]: https://raw.githubusercontent.com/nycolaide/lapikit/main/apps/website/src/lib/images/lapinosaure/lapinosaure.webp

package/bin/configuration.js

@@ -1,23 +1,303 @@
 #!/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.`);
+	}
+
+	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, 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'`)) {
+			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(), ${lapikitPlugin}`
+							);
+							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(), ${lapikitPlugin}`);
+							} 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}${lapikitPlugin}`);
+							}
+							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) {
-	console.log('initConfiguration called with:', options);
-	const { typescript, pathConfig } = 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}`);
 
 	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}`);
-		await fs.writeFile(targetFile, '// lapikit entry file');
-		console.log(`File created : ${targetFile}`);
+		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 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, pathConfig, typescript);
+	} 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/helper.js

@@ -1,6 +1,3 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
 const color = {
 	red: (text) => `\x1b[31m${text}\x1b[0m`,
 	green: (text) => `\x1b[32m${text}\x1b[0m`,
@@ -60,38 +57,3 @@ export const terminal = (type = 'info', msg) => {
 	else if (type === 'none') console.log(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 function getLapikitPathFromArgs() {
-	const args = process.argv.slice(2);
-	// Search argument after --plugin-path or -p
-	const pluginPathIndex = args.findIndex((arg) => arg === '--plugin-path' || arg === '-p');
-	if (pluginPathIndex !== -1 && args[pluginPathIndex + 1]) {
-		return args[pluginPathIndex + 1];
-	}
-	return 'src/plugin';
-}
-
-export function validatePluginPath(pluginPath) {
-	if (!pluginPath.startsWith('src/')) {
-		return {
-			valid: false,
-			error: 'The path must start with "src/"'
-		};
-	}
-	return { valid: true };
-}
-
-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/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { initConfiguration } from './configuration.js';
 import { ansi, terminal } from './helper.js';
-import { legacyConfiguration } from './legacy.js';
 import { initPrompts } from './prompts.js';
 
 async function run() {
@@ -18,24 +17,17 @@ async function run() {
 
 	const promptsConfig = await initPrompts();
 
-	if (promptsConfig.env === 'current') {
-		legacyConfiguration(promptsConfig);
-	}
-
-	if (promptsConfig.env === 'experimental') {
-		terminal('warn', `Experimental mode is not yet implemented.`);
-		initConfiguration(promptsConfig);
-	}
+	await initConfiguration(promptsConfig);
 }
 
 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

@@ -0,0 +1,26 @@
+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/styles';\n`;
+		content += `import 'lapikit/themes';\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

@@ -1,101 +1,67 @@
 #!/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
-	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: 'Common ( CSS / SASS / SCSS / LESS / other libs )', value: 'global' },
-					{
-						title: 'TailwindCSS (v4)',
-						value: 'tailwind-v4'
-					},
-					{
-						title: 'UnoCSS',
-						value: 'unocss'
-					}
-				]
-			},
-			{
-				type: (prev) => (prev !== 'global' ? '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/'
-			}
-		]);
+	// Preview install
+	const 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/'
+		}
+	]);
 
-		console.log('response config', settings);
-
-		return {
-			...settings,
-			env: 'experimental'
-		};
-	}
+	return {
+		...settings
+	};
 }

package/dist/actions/accordion.svelte.d.ts

@@ -0,0 +1,9 @@
+type AccordionOptions = {
+    multiple?: boolean;
+    readOnly?: boolean;
+};
+export declare function useAccordion({ multiple, readOnly }?: AccordionOptions): {
+    readonly values: (string | number)[];
+    toggle(id: string | number): void;
+};
+export {};

package/dist/actions/index.d.ts

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

package/dist/actions/index.js

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

package/dist/actions/use-theme.d.ts

@@ -0,0 +1 @@
+export declare function useTheme(name: string, key?: string): void;

package/dist/actions/use-theme.js

@@ -0,0 +1,18 @@
+import { theme } from '../stores/themes.js';
+// states
+const isBrowser = typeof window !== 'undefined';
+export function useTheme(name, key = '@lapikit/theme') {
+    theme.update(() => {
+        if (isBrowser) {
+            const html = document.documentElement;
+            html.classList.forEach((cls) => {
+                if (cls.startsWith('kit-theme--')) {
+                    html.classList.remove(cls);
+                }
+            });
+            html.classList.add(`kit-theme--${name}`);
+            localStorage.setItem(key, name);
+        }
+        return name;
+    });
+}