lapikit 0.2.2 → 0.2.3

package/bin/configuration.js

@@ -133,10 +133,12 @@ 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'`)) {
@@ -183,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;
@@ -200,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;
 						}
@@ -246,7 +248,7 @@ async function addLapikitToViteConfig(viteConfigFile) {
 }
 
 export async function initConfiguration(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}`);
@@ -287,10 +289,14 @@ 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) {
 		terminal('warn', `Warning: Could not update vite.config file: ${error.message}`);
 		terminal('error', `Error adding lapikit to vite config: ${error.message}`);

package/bin/presets.js

@@ -8,6 +8,7 @@ function presets({ adapterCSS }) {
 
 	if (adapterCSS === 'css') {
 		content += `// Styles\n`;
+		content += `import 'lapikit/styles';\n`;
 		content += `import 'lapikit/css';\n\n`;
 	}
 

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

@@ -1,5 +1,27 @@
 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,5 +1,28 @@
+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/config/presets.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/internal/config/presets.js

@@ -0,0 +1,121 @@
+import { variables } from './variables.js';
+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/internal/config/variables.d.ts

@@ -0,0 +1,6 @@
+export declare const variables: {
+    info: string;
+    success: string;
+    error: string;
+    warning: string;
+};

package/dist/internal/config/variables.js

@@ -0,0 +1,6 @@
+export const variables = {
+    info: 'var(--system-blue)',
+    success: 'var(--system-green)',
+    error: 'var(--system-red)',
+    warning: 'var(--system-yellow)'
+};

package/dist/internal/core/formatter/component.d.ts

@@ -0,0 +1,5 @@
+export declare function componentFormatter({ breakpoints }: {
+    breakpoints: {
+        [key: string]: number | string;
+    };
+}): void;

package/dist/internal/core/formatter/component.js

@@ -0,0 +1,56 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs';
+import path from 'path';
+import { parserCSSBreakpoints } from '../../helpers/parser.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export function componentFormatter({ breakpoints }) {
+    // load css component files (includes on components folders)
+    function loadCSSFiles(directory) {
+        fs.readdirSync(directory).forEach((File) => {
+            const absolutePath = path.join(directory, File);
+            if (fs.statSync(absolutePath).isDirectory())
+                return loadCSSFiles(absolutePath);
+            else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
+                console.log(absolutePath);
+                let css = '';
+                const content = parserCSSBreakpoints(fs.readFileSync(absolutePath, 'utf8'));
+                for (const property in breakpoints) {
+                    if (property !== 'base') {
+                        const name = `.${/^\d/.test(property) ? `\\3${property}` : property}\\:`;
+                        const value = typeof breakpoints[property] === 'number'
+                            ? `${breakpoints[property]}px`
+                            : breakpoints[property];
+                        if (content.base !== '' || content.minmax !== '' || content.min !== '') {
+                            css += `@media screen and (min-width: ${value}) {\n`;
+                            if (content.base !== '')
+                                css += content.base.replaceAll('[breakpoint]', name);
+                            if (content.minmax !== '')
+                                css += content.minmax.replaceAll('[breakpoint]', name);
+                            if (content.min !== '')
+                                css += content.min.replaceAll('[breakpoint]', name);
+                            css += `}\n`;
+                        }
+                        if (content.max !== '' || content.all !== '') {
+                            css += `@media screen and (max-width: ${value}) {\n`;
+                            if (content.max !== '')
+                                css += content.max.replaceAll('[breakpoint]', name);
+                            if (content.all !== '')
+                                css += content.all.replaceAll('[breakpoint]', name);
+                            css += `}\n`;
+                        }
+                    }
+                    else {
+                        css += content.all.replaceAll('[breakpoint]', '.');
+                    }
+                }
+                let formattedCSS = css;
+                formattedCSS = formattedCSS.trim().replace(/\n{3,}/g, '\n\n');
+                console.log(formattedCSS);
+                fs.writeFileSync(absolutePath, formattedCSS, 'utf8');
+            }
+        });
+    }
+    loadCSSFiles(path.resolve(__dirname, '../../../components'));
+}

package/dist/internal/core/formatter/index.d.ts

@@ -0,0 +1,4 @@
+import type { DevConfiguration } from '../../types/index.js';
+export declare function css(config: DevConfiguration): Promise<{
+    styles: string[];
+}>;

package/dist/internal/core/formatter/index.js

@@ -0,0 +1,26 @@
+import { preset } from '../../config/presets.js';
+import { deepMerge } from '../../deepMerge.js';
+import { componentFormatter } from './component.js';
+import { themesFormatter } from './theme.js';
+import { typographyFormatter } from './typography.js';
+export async function css(config) {
+    // states
+    const defaultTheme = config?.theme?.defaultTheme || preset.theme.defaultTheme;
+    const defaultTypography = config?.typography?.defaultTypography || preset.typography.defaultTypography;
+    // formatter
+    const themes = themesFormatter({
+        themes: deepMerge(preset.theme.themes, config?.theme?.themes || {}),
+        defaultTheme
+    });
+    const typography = typographyFormatter({
+        typography: deepMerge(preset.typography.fonts, config?.typography?.fonts || {}),
+        defaultTypography
+    });
+    // components
+    componentFormatter({
+        breakpoints: deepMerge(preset.breakpoints.thresholds, config?.breakpoints?.thresholds || {})
+    });
+    return {
+        styles: [themes, typography]
+    };
+}

package/dist/internal/core/formatter/styles.d.ts

@@ -0,0 +1,4 @@
+import type { FragStyles } from '../../types/configuration.js';
+export declare function stylesFormatter({ styles }: {
+    styles: FragStyles;
+}): string;

package/dist/internal/core/formatter/styles.js

@@ -0,0 +1,15 @@
+import { parserValues } from '../../helpers/parser.js';
+export function stylesFormatter({ styles }) {
+    let css = `:root {\n`;
+    for (const [name, values] of Object.entries(styles)) {
+        if (values && typeof values === 'object') {
+            for (const [styleName, styleValue] of Object.entries(values || {})) {
+                css += `  --prism-${name}-${styleName}: ${parserValues(styleValue)};\n`;
+            }
+        }
+        else {
+            css += `  --prism-${name}: ${parserValues(values)};\n`;
+        }
+    }
+    return (css += '}\n');
+}

package/dist/internal/core/formatter/theme.d.ts

@@ -0,0 +1,5 @@
+import type { FragThemes } from '../../types/index.js';
+export declare function themesFormatter({ themes, defaultTheme }: {
+    themes: FragThemes;
+    defaultTheme: string;
+}): string;

package/dist/internal/core/formatter/theme.js

@@ -0,0 +1,20 @@
+import { preset } from '../../config/presets.js';
+import { deepMerge } from '../../deepMerge.js';
+export function themesFormatter({ themes, defaultTheme = 'light' }) {
+    let css = '';
+    for (const [name, values] of Object.entries(themes)) {
+        const ref = values?.dark ? preset.theme.themes.dark : preset.theme.themes.light;
+        let cssTheme = defaultTheme === name ? `:root,\n.${name} {\n` : `.${name} {\n`;
+        // colors
+        cssTheme += `  color-scheme: ${values?.dark ? 'dark' : 'light'};\n`;
+        for (const [varName, varValue] of Object.entries(deepMerge(ref.colors, values?.colors) || {})) {
+            cssTheme += `  --system-${varName}: ${varValue};\n`;
+        }
+        // variables
+        for (const [name, varValue] of Object.entries(deepMerge(ref.variables, values?.variables) || {})) {
+            cssTheme += `  --kit-${name}: ${varValue};\n`;
+        }
+        css += cssTheme + '}\n';
+    }
+    return css;
+}

package/dist/internal/core/formatter/typography.d.ts

@@ -0,0 +1,5 @@
+import type { FragTypography } from '../../types/configuration.js';
+export declare function typographyFormatter({ typography, defaultTypography }: {
+    typography: FragTypography;
+    defaultTypography: string;
+}): string;

package/dist/internal/core/formatter/typography.js

@@ -0,0 +1,12 @@
+import { parserValues } from '../../helpers/parser.js';
+export function typographyFormatter({ typography, defaultTypography = 'default' }) {
+    let css = '';
+    for (const [name, values] of Object.entries(typography)) {
+        let cssTypo = defaultTypography === name ? `:root {\n` : `.${name} {\n`;
+        for (const [fontName, fontValue] of Object.entries(values || {})) {
+            cssTypo += `  --kit-font-${fontName}: ${parserValues(fontValue)};\n`;
+        }
+        css += cssTypo + '}\n';
+    }
+    return css;
+}

package/dist/internal/core/parser-config.d.ts

@@ -0,0 +1 @@
+export declare function getLapikitConfig(filePath: string): Promise<{}>;

package/dist/internal/core/parser-config.js

@@ -0,0 +1,24 @@
+import path from 'path';
+import fs from 'fs';
+import { terminal } from '../terminal.js';
+const app = process.cwd();
+export 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) {
+            terminal('error', `error parsing lapikit config: ${e}`);
+        }
+    }
+    else {
+        terminal('info', 'lapikit config has loaded successfully!');
+    }
+    return options;
+}

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