lapikit 0.2.3 → 0.2.4

package/dist/internal/config/presets.js

@@ -1,10 +1,11 @@
 import { variables } from './variables.js';
+import standardColors from '../core/standard-colors.js';
 export const preset = {
     breakpoints: {
         devices: {
             desktop: 1024, //64rem (lg)
             tablet: 768, //48rem (md)
-            mobile: 375 //28rem (sm)
+            mobile: 640 //40rem (sm)
         },
         thresholds: {
             base: 0, // 0px
@@ -19,56 +20,86 @@ export const preset = {
     },
     theme: {
         defaultTheme: 'light',
+        colorScheme: true,
         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)'
+                    label: {
+                        primary: '#000000',
+                        secondary: standardColors.gray.light,
+                        tertiary: standardColors.gray2.light,
+                        quaternary: standardColors.gray3.light
+                    },
+                    accent: {
+                        primary: standardColors.blue.light,
+                        success: standardColors.green.light,
+                        warning: standardColors.orange.light,
+                        destructive: standardColors.red.light,
+                        info: standardColors.cyan.light
+                    },
+                    separator: {
+                        default: standardColors.gray3.light,
+                        opaque: standardColors.gray4.light
+                    },
+                    state: {
+                        placeholder: standardColors.gray3.light,
+                        disabled: standardColors.gray2.light,
+                        link: standardColors.blue.light,
+                        highlight: standardColors.gray5.light,
+                        shadow: '#00000033'
+                    },
+                    background: {
+                        primary: '#FFFFFF',
+                        secondary: standardColors.gray6.light,
+                        tertiary: standardColors.gray5.light,
+                        grouped: {
+                            primary: standardColors.gray6.light,
+                            secondary: '#FFFFFF',
+                            tertiary: standardColors.gray6.light
+                        }
+                    }
                 },
                 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)'
+                    pink: 'pink',
+                    label: {
+                        primary: '#FFFFFF',
+                        secondary: standardColors.gray2.dark,
+                        tertiary: standardColors.gray3.dark,
+                        quaternary: standardColors.gray4.dark
+                    },
+                    accent: {
+                        primary: standardColors.blue.dark,
+                        success: standardColors.green.dark,
+                        warning: standardColors.orange.dark,
+                        destructive: standardColors.red.dark,
+                        info: standardColors.cyan.dark
+                    },
+                    separator: {
+                        default: standardColors.gray3.dark,
+                        opaque: standardColors.gray4.dark
+                    },
+                    state: {
+                        placeholder: standardColors.gray3.dark,
+                        disabled: standardColors.gray4.dark,
+                        link: standardColors.blue.dark,
+                        highlight: standardColors.gray5.dark,
+                        shadow: '#00000066'
+                    },
+                    background: {
+                        primary: '#000000',
+                        secondary: standardColors.gray6.dark,
+                        tertiary: standardColors.gray5.dark,
+                        grouped: {
+                            primary: standardColors.gray6.dark,
+                            secondary: standardColors.gray5.dark,
+                            tertiary: standardColors.gray4.dark
+                        }
+                    }
                 },
                 variables: variables
             }
@@ -116,6 +147,23 @@ export const preset = {
             '2xl': '1rem', // 16px
             '3xl': '1.5rem', // 24px
             full: '9999px' // 9999px
+        },
+        dialog: {
+            xs: '18.75rem', // 300px
+            sm: '25rem', // 400px
+            md: '37.5rem', // 600px
+            lg: '53.125rem', // 850px
+            xl: '75rem' // 1200px
+        },
+        modal: {
+            xs: '18.75rem', // 300px
+            sm: '25rem', // 400px
+            md: '37.5rem', // 600px
+            lg: '53.125rem', // 850px
+            xl: '75rem' // 1200px
+        },
+        animation: {
+            'ripple-duration': '0.4s'
         }
     }
 };

package/dist/internal/config/variables.d.ts

@@ -1,6 +1,3 @@
 export declare const variables: {
-    info: string;
-    success: string;
-    error: string;
-    warning: string;
+    'test-variable': string;
 };

package/dist/internal/config/variables.js

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

package/dist/internal/{assets.svelte.js → core/actions/assets.svelte.js}

@@ -1,11 +1,11 @@
-import { x11ColorNames } from '../utils/x11.js';
+import { x11ColorNames } from '../x11-colors.js';
 export function getAssets() {
     return {
         shape(params) {
             if (params) {
                 if (params === 'none' || params == '0')
                     return '0';
-                return `var(--kit-radius-${params})`;
+                return `var(--system-shape-${params})`;
             }
         },
         className(key, type, value) {
@@ -16,12 +16,12 @@ export function getAssets() {
             else if (typeof value === 'object') {
                 if (Array.isArray(value)) {
                     return value
-                        .map((media) => `${media === '_default' ? '' : `${media}:`}kit--${type}`)
+                        .map((media) => `${media === 'base' ? '' : `${media}:`}kit--${type}`)
                         .join(' ');
                 }
                 else {
                     return Object.entries(value)
-                        .map(([media, value]) => `${media === '_default' ? '' : `${media}:`}kit-${key}--${type}-${value}`)
+                        .map(([media, value]) => `${media === 'base' ? '' : `${media}:`}kit-${key}--${type}-${value}`)
                         .join(' ');
                 }
             }

package/dist/internal/core/actions/dropdown.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { PositionElement } from '../../../components/dropdown/types.js';
+type Location = 'top' | 'bottom' | 'left' | 'right';
+export declare function getPositions(): {
+    readonly values: PositionElement;
+    update(activator: HTMLElement | PointerEvent, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
+};
+export {};

package/dist/internal/core/actions/popover.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { PositionElement } from '../../../components/popover/types.js';
+type Location = 'top' | 'bottom' | 'left' | 'right';
+export declare function getPositions(): {
+    readonly values: PositionElement;
+    update(activator: HTMLElement, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
+};
+export {};

package/dist/internal/core/actions/tooltip.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { PositionElement } from '../../../components/tooltip/types.js';
+type Location = 'top' | 'bottom' | 'left' | 'right';
+export declare function getPositionsTooltip(): {
+    readonly values: PositionElement;
+    update(activator: HTMLElement, element: HTMLElement, location?: Location, centered?: boolean, avoidCollisions?: boolean): void;
+};
+export {};

package/dist/internal/{ripple.js → core/animations/ripple.js}

@@ -27,13 +27,13 @@ export function ripple(el, options = {}) {
             options.duration = undefined;
         }
         if (options.component) {
-            rippleContainer.style.setProperty('--ripple-radius', `var(--${options.component}-radius)`);
+            rippleContainer.style.setProperty('--system-ripple-radius', `var(--${options.component}-radius)`);
         }
         if (options.color) {
-            rippleContainer.style.setProperty('--ripple-color', options.color);
+            rippleContainer.style.setProperty('--system-ripple-color', options.color);
         }
         if (options.duration) {
-            rippleContainer.style.setProperty('--ripple-duration', `${options.duration}ms`);
+            rippleContainer.style.setProperty('--system-animation-ripple-duration', `${options.duration}ms`);
         }
     }
     function createRipple(e, center) {

package/dist/internal/core/css.d.ts

@@ -0,0 +1 @@
+export declare const processImportStyles: () => Promise<string>;

package/dist/internal/core/css.js

@@ -0,0 +1,16 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const processImportStyles = async () => {
+    const _reset = fs.readFileSync(path.resolve(__dirname, './../../styles/reset.css'), 'utf-8');
+    const _animation = fs.readFileSync(path.resolve(__dirname, './../../styles/animation.css'), 'utf-8');
+    const _keyframes = fs.readFileSync(path.resolve(__dirname, './../../styles/keyframes.css'), 'utf-8');
+    let styles = ``;
+    styles += `${_reset}\n`;
+    styles += `${_animation}\n`;
+    styles += `${_keyframes}\n`;
+    return styles;
+};

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

@@ -2,4 +2,4 @@ export declare function componentFormatter({ breakpoints }: {
     breakpoints: {
         [key: string]: number | string;
     };
-}): void;
+}): Promise<void>;

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

@@ -5,17 +5,17 @@ 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) {
+export async function componentFormatter({ breakpoints }) {
+    // load svelte component files (includes on components folders)
+    function loadSvelteFiles(directory) {
         fs.readdirSync(directory).forEach((File) => {
             const absolutePath = path.join(directory, File);
             if (fs.statSync(absolutePath).isDirectory())
-                return loadCSSFiles(absolutePath);
+                return loadSvelteFiles(absolutePath);
             else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
-                console.log(absolutePath);
-                let css = '';
-                const content = parserCSSBreakpoints(fs.readFileSync(absolutePath, 'utf8'));
+                const fileCSS = fs.readFileSync(absolutePath, 'utf8');
+                const content = parserCSSBreakpoints(fileCSS);
+                let css = `${content.cleaned}\n`;
                 for (const property in breakpoints) {
                     if (property !== 'base') {
                         const name = `.${/^\d/.test(property) ? `\\3${property}` : property}\\:`;
@@ -23,34 +23,38 @@ export function componentFormatter({ breakpoints }) {
                             ? `${breakpoints[property]}px`
                             : breakpoints[property];
                         if (content.base !== '' || content.minmax !== '' || content.min !== '') {
-                            css += `@media screen and (min-width: ${value}) {\n`;
+                            css += `\n@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`;
+                            css += `\n}\n`;
                         }
-                        if (content.max !== '' || content.all !== '') {
-                            css += `@media screen and (max-width: ${value}) {\n`;
+                        if (content.max !== '' || content.minmax !== '') {
+                            css += `\n@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`;
+                                css += content.max.replaceAll('[breakpoint]', `max\\:${name}`);
+                            if (content.minmax !== '')
+                                css += content.all.replaceAll('[breakpoint]', `max\\:${name}`);
+                            css += `\n}\n`;
                         }
                     }
                     else {
-                        css += content.all.replaceAll('[breakpoint]', '.');
+                        css += `${content.base.replaceAll('[breakpoint]', '.')}\n`;
                     }
                 }
-                let formattedCSS = css;
-                formattedCSS = formattedCSS.trim().replace(/\n{3,}/g, '\n\n');
-                console.log(formattedCSS);
-                fs.writeFileSync(absolutePath, formattedCSS, 'utf8');
+                const baseName = path.basename(absolutePath, '.css');
+                const svelteFilePath = path.join(path.dirname(absolutePath), `${baseName}.svelte`);
+                if (fs.existsSync(svelteFilePath)) {
+                    let svelteContent = fs.readFileSync(svelteFilePath, 'utf8');
+                    svelteContent = svelteContent.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+                    svelteContent += `<style>\n${css}</style>`;
+                    fs.writeFileSync(svelteFilePath, svelteContent, 'utf8');
+                }
             }
         });
     }
-    loadCSSFiles(path.resolve(__dirname, '../../../components'));
+    loadSvelteFiles(path.resolve(__dirname, '../../../components'));
 }

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

@@ -0,0 +1,5 @@
+export declare function devicesFormatter({ devices }: {
+    devices: {
+        [key: string]: number | string;
+    };
+}): Promise<string>;

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

@@ -0,0 +1,66 @@
+import { parserValues } from '../../helpers/parser.js';
+export async function devicesFormatter({ devices }) {
+    let css = ``;
+    const sortedDevices = Object.entries(devices).sort(([, a], [, b]) => {
+        const valueA = typeof a === 'string' ? parseInt(a) : a;
+        const valueB = typeof b === 'string' ? parseInt(b) : b;
+        return valueB - valueA;
+    });
+    sortedDevices.forEach(([deviceName, breakpoint], index) => {
+        const value = parserValues(breakpoint);
+        if (index === 0) {
+            // the largest device
+            css += `@media (max-width: ${value}) {\n`;
+            css += ` .kit-device--d-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+            css += `@media (min-width: ${value}) {\n`;
+            css += ` .kit-device--h-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+        }
+        else if (index === sortedDevices.length - 1) {
+            const prevDevice = sortedDevices[index - 1];
+            const prevValue = parserValues(prevDevice[1]);
+            // the smallest device
+            css += `@media (min-width: ${prevValue}) {\n`;
+            css += ` .kit-device--d-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+            css += `@media (max-width: ${prevValue}) {\n`;
+            css += ` .kit-device--h-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+            css += `@media (min-width: ${value}) {\n`;
+            css += ` .kit-device--od-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+            css += `@media (max-width: ${value}) {\n`;
+            css += ` .kit-device--oh-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+        }
+        else {
+            //intermediate devices
+            const nextDevice = sortedDevices[index - 1];
+            const nextValue = parserValues(nextDevice[1]);
+            css += `@media (max-width: ${value}) {\n`;
+            css += ` .kit-device--d-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+            css += `@media (min-width: ${nextValue}) {\n`;
+            css += ` .kit-device--h-${deviceName} {\n`;
+            css += `   display: none !important;\n`;
+            css += ` }\n`;
+            css += `}\n\n`;
+        }
+    });
+    return css.trim();
+}

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

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

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

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

package/dist/internal/core/formatter/{styles.d.ts → style.d.ts}

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

package/dist/internal/core/formatter/{styles.js → style.js}

@@ -1,14 +1,14 @@
 import { parserValues } from '../../helpers/parser.js';
-export function stylesFormatter({ styles }) {
+export async 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`;
+                css += `  --system-${name}-${styleName}: ${parserValues(styleValue)};\n`;
             }
         }
         else {
-            css += `  --prism-${name}: ${parserValues(values)};\n`;
+            css += `  --system-${name}: ${parserValues(values)};\n`;
         }
     }
     return (css += '}\n');

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

@@ -2,4 +2,4 @@ import type { FragThemes } from '../../types/index.js';
 export declare function themesFormatter({ themes, defaultTheme }: {
     themes: FragThemes;
     defaultTheme: string;
-}): string;
+}): Promise<string>;

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

@@ -1,18 +1,42 @@
 import { preset } from '../../config/presets.js';
-import { deepMerge } from '../../deepMerge.js';
-export function themesFormatter({ themes, defaultTheme = 'light' }) {
+import { formatColor } from '../../helpers/colors.js';
+import { deepMerge } from '../../helpers/deep-merge.js';
+import { parserValues } from '../../helpers/parser.js';
+export async 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`;
+        let cssTheme = defaultTheme === name ? `:root,\n.kit-theme--${name} {\n` : `.kit-theme--${name} {\n`;
+        function flattenColors(obj, prefix = '') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const newPrefix = prefix ? `${prefix}-${key}` : key;
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    Object.assign(result, flattenColors(value, newPrefix));
+                }
+                else {
+                    result[newPrefix] = value;
+                }
+            }
+            return result;
+        }
         // 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`;
+        const mergedColors = deepMerge(ref.colors, values?.colors) || {};
+        const flatColors = flattenColors(mergedColors);
+        for (const [varName, varValue] of Object.entries(flatColors)) {
+            cssTheme += `  --kit-${varName}: ${formatColor(varValue)};\n`;
         }
         // variables
         for (const [name, varValue] of Object.entries(deepMerge(ref.variables, values?.variables) || {})) {
-            cssTheme += `  --kit-${name}: ${varValue};\n`;
+            if (varValue && typeof varValue === 'object') {
+                for (const [variableName, variableValue] of Object.entries(varValue || {})) {
+                    cssTheme += `  --kit-${name}-${variableName}: ${formatColor(parserValues(variableValue))};\n`;
+                }
+            }
+            else {
+                cssTheme += `  --kit-${name}: ${formatColor(parserValues(varValue))};\n`;
+            }
         }
         css += cssTheme + '}\n';
     }

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

@@ -2,4 +2,4 @@ import type { FragTypography } from '../../types/configuration.js';
 export declare function typographyFormatter({ typography, defaultTypography }: {
     typography: FragTypography;
     defaultTypography: string;
-}): string;
+}): Promise<string>;

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

@@ -1,10 +1,10 @@
 import { parserValues } from '../../helpers/parser.js';
-export function typographyFormatter({ typography, defaultTypography = 'default' }) {
+export async 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`;
+            cssTypo += `  --kit-font-${fontName}: ${parserValues(fontValue).replaceAll('"', '')};\n`;
         }
         css += cssTypo + '}\n';
     }