lapikit 0.2.0 → 0.2.2

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/helper.js

@@ -1,3 +1,6 @@
+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`,
@@ -63,6 +66,26 @@ export function getCssPathFromArgs() {
 	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 {

package/bin/index.js

@@ -0,0 +1,41 @@
+#!/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() {
+	console.log('  _                 _ _    _ _   ');
+	console.log(' | |               (_) |  (_) |  ');
+	console.log(' | |     __ _ _ __  _| | ___| |_ ');
+	console.log(" | |    / _` | '_ \\| | |/ / | __|");
+	console.log(' | |___| (_| | |_) | |   <| | |_ ');
+	console.log(' |______\\__,_| .__/|_|_|\\_\\_|\\__|');
+	console.log('             | |                 ');
+	console.log('             |_|                 \n');
+
+	terminal('none', `${ansi.bold.blue('Lapikit')} - Component Library for Svelte\n\n`);
+
+	const promptsConfig = await initPrompts();
+
+	if (promptsConfig.env === 'current') {
+		await legacyConfiguration(promptsConfig);
+	}
+
+	if (promptsConfig.env === 'experimental') {
+		terminal('warn', `Experimental mode is not yet implemented.`);
+		await initConfiguration(promptsConfig);
+	}
+}
+
+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/lapikit.js

@@ -1,9 +1,16 @@
 #!/usr/bin/env node
 import { promises as fs } from 'fs';
 import path from 'path';
-import { ansi, terminal, envTypescript } from './helper.js';
+import {
+	ansi,
+	terminal,
+	envTypescript,
+	getLapikitPathFromArgs,
+	validatePluginPath
+} from './helper.js';
 import { preset } from './modules/preset.js';
 import { adapterCSSConfig, adapterViteConfig } from './modules/adapter.js';
+import { createPluginStructure, setupSvelteKitIntegration } from './modules/plugin.js';
 
 const [, , command] = process.argv;
 const typescriptEnabled = envTypescript();
@@ -11,8 +18,9 @@ const typescriptEnabled = envTypescript();
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
 	terminal(
 		'info',
-		`usage: ${ansi.color.yellow('npx lapikit init {cssPath}')}\n\n ${ansi.variant.bold('options:')}\n
-        - {cssPath}: (${ansi.color.cyan('src/app.css')}) customize path on your origin css file.\n\n`
+		`usage: ${ansi.color.yellow('npx lapikit init {cssPath} [--plugin-path {pluginPath}]')}\n\n ${ansi.variant.bold('options:')}\n
+        - {cssPath}: (${ansi.color.cyan('src/app.css')}) customize path on your origin css file.
+        - --plugin-path, -p: (${ansi.color.cyan('src/plugin')}) customize path for the plugin directory.\n\n`
 	);
 	process.exit(0);
 } else if (command === 'init') {
@@ -27,6 +35,15 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
 
 	terminal('none', `${ansi.bold.blue('LAPIKIT')} - Component Library for Svelte\n\n`);
 
+	// Get Path
+	const pluginPath = getLapikitPathFromArgs();
+	const pathValidation = validatePluginPath(pluginPath);
+
+	if (!pathValidation.valid) {
+		terminal('error', `Invalid path: ${pathValidation.error}`);
+		process.exit(1);
+	}
+
 	const configPath = path.resolve(process.cwd(), 'lapikit.config.js');
 	try {
 		await fs.writeFile(configPath, preset.trim() + '\n', 'utf8');
@@ -39,6 +56,20 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
 		);
 	}
 
+	// Create plugin structure
+	try {
+		await createPluginStructure(pluginPath, typescriptEnabled);
+	} catch (error) {
+		terminal('error', `Create plugin structure not working : ${error.message}`);
+	}
+
+	// Setup SvelteKit integration
+	try {
+		await setupSvelteKitIntegration(pluginPath, typescriptEnabled);
+	} catch (error) {
+		terminal('error', `SvelteKit integration setup failed: ${error.message}`);
+	}
+
 	await adapterViteConfig(typescriptEnabled);
 	await adapterCSSConfig();
 

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);