lapikit 0.0.0-insiders.e877f7f → 0.0.0-insiders.eb9b51b

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

@@ -0,0 +1,60 @@
+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 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 loadSvelteFiles(absolutePath);
+            else if (absolutePath.endsWith('.css') && !absolutePath.includes('/_')) {
+                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}\\:`;
+                        const value = typeof breakpoints[property] === 'number'
+                            ? `${breakpoints[property]}px`
+                            : breakpoints[property];
+                        if (content.base !== '' || content.minmax !== '' || content.min !== '') {
+                            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}\n`;
+                        }
+                        if (content.max !== '' || content.minmax !== '') {
+                            css += `\n@media screen and (max-width: ${value}) {\n`;
+                            if (content.max !== '')
+                                css += content.max.replaceAll('[breakpoint]', `max\\:${name}`);
+                            if (content.minmax !== '')
+                                css += content.all.replaceAll('[breakpoint]', `max\\:${name}`);
+                            css += `\n}\n`;
+                        }
+                    }
+                    else {
+                        css += `${content.base.replaceAll('[breakpoint]', '.')}\n`;
+                    }
+                }
+                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');
+                }
+            }
+        });
+    }
+    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

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

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

@@ -0,0 +1,35 @@
+import { preset } from '../../config/presets.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 liliRabbit(config) {
+    // states
+    const defaultTheme = config?.theme?.defaultTheme || preset.theme.defaultTheme;
+    const defaultTypography = config?.typography?.defaultTypography || preset.typography.defaultTypography;
+    // formatter
+    const themes = await themesFormatter({
+        themes: deepMerge(preset.theme.themes, config?.theme?.themes || {}),
+        defaultTheme
+    });
+    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
+    await componentFormatter({
+        breakpoints: deepMerge(preset.breakpoints.thresholds, config?.breakpoints?.thresholds || {})
+    });
+    return {
+        themes: themes,
+        typography: typography,
+        styles: styles,
+        devices: devices
+    };
+}

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

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

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

@@ -0,0 +1,15 @@
+import { parserValues } from '../../helpers/parser.js';
+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 += `  --system-${name}-${styleName}: ${parserValues(styleValue)};\n`;
+            }
+        }
+        else {
+            css += `  --system-${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;
+}): Promise<string>;

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

@@ -0,0 +1,44 @@
+import { preset } from '../../config/presets.js';
+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.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`;
+        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) || {})) {
+            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';
+    }
+    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;
+}): Promise<string>;

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

@@ -0,0 +1,12 @@
+import { parserValues } from '../../helpers/parser.js';
+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).replaceAll('"', '')};\n`;
+        }
+        css += cssTypo + '}\n';
+    }
+    return css;
+}

package/dist/internal/core/standard-colors.d.ts

@@ -0,0 +1,75 @@
+export declare const standardColors: {
+    red: {
+        light: string;
+        dark: string;
+    };
+    orange: {
+        light: string;
+        dark: string;
+    };
+    yellow: {
+        light: string;
+        dark: string;
+    };
+    green: {
+        light: string;
+        dark: string;
+    };
+    mint: {
+        light: string;
+        dark: string;
+    };
+    teal: {
+        light: string;
+        dark: string;
+    };
+    cyan: {
+        light: string;
+        dark: string;
+    };
+    blue: {
+        light: string;
+        dark: string;
+    };
+    indigo: {
+        light: string;
+        dark: string;
+    };
+    purple: {
+        light: string;
+        dark: string;
+    };
+    pink: {
+        light: string;
+        dark: string;
+    };
+    brown: {
+        light: string;
+        dark: string;
+    };
+    gray: {
+        light: string;
+        dark: string;
+    };
+    gray2: {
+        light: string;
+        dark: string;
+    };
+    gray3: {
+        light: string;
+        dark: string;
+    };
+    gray4: {
+        light: string;
+        dark: string;
+    };
+    gray5: {
+        light: string;
+        dark: string;
+    };
+    gray6: {
+        light: string;
+        dark: string;
+    };
+};
+export default standardColors;

package/dist/internal/core/standard-colors.js

@@ -0,0 +1,75 @@
+export const standardColors = {
+    red: {
+        light: '#FF3B30',
+        dark: '#FF453A'
+    },
+    orange: {
+        light: '#FF9500',
+        dark: '#FF9F0A'
+    },
+    yellow: {
+        light: '#FFCC00',
+        dark: '#FFD60A'
+    },
+    green: {
+        light: '#34C759',
+        dark: '#30D158'
+    },
+    mint: {
+        light: '#00C7BE',
+        dark: '#66D4CF'
+    },
+    teal: {
+        light: '#30B0C7',
+        dark: '#40CBE0'
+    },
+    cyan: {
+        light: '#32ADE6',
+        dark: '#64D2FF'
+    },
+    blue: {
+        light: '#007AFF',
+        dark: '#0A84FF'
+    },
+    indigo: {
+        light: '#5856D6',
+        dark: '#5E5CE6'
+    },
+    purple: {
+        light: '#AF52DE',
+        dark: '#BF5AF2'
+    },
+    pink: {
+        light: '#FF2D55',
+        dark: '#FF375F'
+    },
+    brown: {
+        light: '#A2845E',
+        dark: '#AC8E68'
+    },
+    gray: {
+        light: '#8E8E93',
+        dark: '#8E8E93'
+    },
+    gray2: {
+        light: '#AEAEB2',
+        dark: '#636366'
+    },
+    gray3: {
+        light: '#C7C7CC',
+        dark: '#48484A'
+    },
+    gray4: {
+        light: '#D1D1D6',
+        dark: '#3A3A3C'
+    },
+    gray5: {
+        light: '#E5E5EA',
+        dark: '#2C2C2E'
+    },
+    gray6: {
+        light: '#F2F2F7',
+        dark: '#1C1C1E'
+    }
+};
+export default standardColors;

package/dist/internal/helpers/colors.d.ts

@@ -0,0 +1 @@
+export declare const formatColor: (input: string) => string;

package/dist/internal/{colors.js → helpers/colors.js}

@@ -1,5 +1,5 @@
-import { x11Colors } from '../utils/x11.js';
-export const parseColor = (input) => {
+import { x11Colors } from '../core/x11-colors.js';
+export const formatColor = (input) => {
     input = input.trim();
     if (input.startsWith('#')) {
         const rgb = hexToRgb(input);

package/dist/internal/helpers/convert.d.ts

@@ -0,0 +1 @@
+export declare function valueToPx(value: string | number): number;

package/dist/internal/helpers/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/dist/internal/helpers/deep-merge.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/helpers/deep-merge.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/helpers/parser.d.ts

@@ -0,0 +1,10 @@
+export declare const parserValues: (value: string | number | Array<string | number>) => string;
+export declare const parserCSSBreakpoints: (css: string) => {
+    all: string;
+    base: string;
+    min: string;
+    max: string;
+    minmax: string;
+    cleaned: string;
+};
+export declare const parserConfigLapikit: (app: string, filePath: string) => Promise<{}>;