lapikit 0.2.2 → 0.2.3

package/dist/internal/deepMerge.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,9 @@
+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;
+};

package/dist/internal/helpers/parser.js

@@ -0,0 +1,70 @@
+export const parserValues = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value;
+};
+export const parserCSSBreakpoints = (css) => {
+    const regex = /([^{]+)\{([^}]+)\}/g;
+    let match;
+    const matchesToRemove = [];
+    const extractedByType = {
+        all: [],
+        base: [],
+        min: [],
+        max: [],
+        minmax: []
+    };
+    while ((match = regex.exec(css)) !== null) {
+        const fullMatch = match[0];
+        const selectors = match[1].trim();
+        const body = match[2].trim();
+        const selectorsArray = selectors.split(',').map((sel) => sel.trim());
+        let matchedType = null;
+        if (selectorsArray.some((sel) => sel.includes('[breakpoint|min]'))) {
+            matchedType = 'min';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|max]'))) {
+            matchedType = 'max';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint|all]'))) {
+            matchedType = 'minmax';
+        }
+        else if (selectorsArray.some((sel) => sel.includes('[breakpoint]'))) {
+            matchedType = 'base';
+        }
+        if (matchedType) {
+            const rule = `${selectors} {\n${body}\n}`;
+            extractedByType.allExtracted.push(rule);
+            extractedByType[matchedType].push(rule);
+            matchesToRemove.push(fullMatch);
+        }
+    }
+    let cleaned = css;
+    for (const rule of matchesToRemove) {
+        cleaned = cleaned.replace(rule, '').replace(/\n{2,}/g, '\n\n');
+    }
+    return {
+        all: extractedByType.allExtracted
+            .join('\n\n')
+            .replaceAll('[breakpoint|min]', '[breakpoint]')
+            .replaceAll('[breakpoint|max]', '[breakpoint]')
+            .replaceAll('[breakpoint|all]', '[breakpoint]')
+            .trim(),
+        base: extractedByType.defaultExtracted.join('\n\n').trim(),
+        min: extractedByType.minExtracted
+            .join('\n\n')
+            .replaceAll('[breakpoint|min]', '[breakpoint]')
+            .trim(),
+        max: extractedByType.maxExtracted
+            .join('\n\n')
+            .replaceAll('[breakpoint|max]', '[breakpoint]')
+            .trim(),
+        minmax: extractedByType.allModifierExtracted
+            .join('\n\n')
+            .replaceAll('[breakpoint|all]', '[breakpoint]')
+            .trim(),
+        cleaned: cleaned.trim()
+    };
+};

package/dist/internal/types/configuration.d.ts

@@ -0,0 +1,40 @@
+export interface DevConfiguration {
+    breakpoints?: {
+        devices?: {
+            [key: string]: number | string;
+        };
+        thresholds?: {
+            [key: string]: number | string;
+        };
+    };
+    theme?: {
+        defaultTheme?: string;
+        themes?: FragThemes;
+    };
+    typography?: {
+        defaultTypography?: string;
+        fonts?: FragTypography;
+    };
+    styles?: FragStyles;
+}
+export interface FragThemes {
+    [key: string]: {
+        dark?: boolean;
+        colors?: {
+            [key: string]: string;
+        };
+        variables?: {
+            [key: string]: string | number;
+        };
+    };
+}
+export interface FragTypography {
+    [key: string]: {
+        [key: string]: string | string[];
+    };
+}
+export interface FragStyles {
+    [key: string]: string | number | {
+        [key: string]: string | number;
+    };
+}

package/dist/internal/types/configuration.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/types/index.d.ts

@@ -0,0 +1 @@
+export * from './configuration.js';

package/dist/internal/types/index.js

@@ -0,0 +1 @@
+export * from './configuration.js';

package/dist/labs/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CompoGlobal } from './my-component-style-global.svelte';
+export { default as CompoMixed } from './my-component-style-mixed.svelte';
+export { default as CompoLocal } from './my-component.svelte';
+export { default as CompoImport } from './my-component-style-import.svelte';

package/dist/labs/index.js

@@ -0,0 +1,5 @@
+// components
+export { default as CompoGlobal } from './my-component-style-global.svelte';
+export { default as CompoMixed } from './my-component-style-mixed.svelte';
+export { default as CompoLocal } from './my-component.svelte';
+export { default as CompoImport } from './my-component-style-import.svelte';

package/dist/labs/my-component-style-global.svelte

@@ -0,0 +1,6 @@
+<script lang="ts">
+</script>
+
+<div class="my-compo-style-global">
+	<h1>Hello World Lapikit Global</h1>
+</div>

package/dist/labs/my-component-style-global.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MyComponentStyleGlobal: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MyComponentStyleGlobal = InstanceType<typeof MyComponentStyleGlobal>;
+export default MyComponentStyleGlobal;

package/dist/labs/my-component-style-import.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+</script>
+
+<div class="my-compo-style-import">
+	<h1>Hello World Lapikit (import styles)</h1>
+</div>
+
+<style>.my-compo-style-import {
+	padding: 2.5rem;
+}
+
+.my-compo-style-import h1 {
+	color: orangered;
+}
+</style>

package/dist/labs/my-component-style-import.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MyComponentStyleImport: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MyComponentStyleImport = InstanceType<typeof MyComponentStyleImport>;
+export default MyComponentStyleImport;

package/dist/labs/my-component-style-mixed.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+</script>
+
+<div class="my-compo-style-mixed">
+	<h1>Hello World Lapikit Mixed</h1>
+</div>
+
+<style>.my-compo-style-mixed {
+	padding: 5.5rem;
+}
+
+.my-compo-style-mixed h1 {
+	color: rgb(101, 52, 218);
+}
+
+div {
+		padding: 2rem;
+	}
+
+h1 {
+		color: rgb(101, 52, 218);
+	}
+</style>

package/dist/labs/my-component-style-mixed.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MyComponentStyleMixed: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MyComponentStyleMixed = InstanceType<typeof MyComponentStyleMixed>;
+export default MyComponentStyleMixed;

package/dist/labs/my-component.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+</script>
+
+<div class="my-compo-style-local">
+	<h1>Hello World Lapikit</h1>
+</div>
+
+<style>
+	div {
+		padding: 2rem;
+	}
+
+	h1 {
+		color: purple;
+	}
+</style>

package/dist/labs/my-component.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MyComponent: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MyComponent = InstanceType<typeof MyComponent>;
+export default MyComponent;

package/dist/labs/style-mixed.css

@@ -0,0 +1,7 @@
+.my-compo-style-mixed {
+	padding: 5.5rem;
+}
+
+.my-compo-style-mixed h1 {
+	color: rgb(101, 52, 218);
+}

package/dist/labs/style.css

@@ -0,0 +1,7 @@
+.my-compo-style-import {
+	padding: 2.5rem;
+}
+
+.my-compo-style-import h1 {
+	color: orangered;
+}

package/dist/labs.css

@@ -0,0 +1,25 @@
+/* The future of css lapikit */
+
+.my-compo-style-global {
+	padding: 1.5rem;
+}
+
+.my-compo-style-global h1 {
+	color: greenyellow;
+}
+
+@media (max-width: 480px) {
+	:root {
+		--active-bp: sm;
+	}
+}
+@media (max-width: 768px) {
+	:root {
+		--active-bp: md;
+	}
+}
+@media (max-width: 1024px) {
+	:root {
+		--active-bp: lg;
+	}
+}

package/dist/plugin/css.d.ts

@@ -0,0 +1 @@
+export declare function css(configuration: any): Promise<void>;

package/dist/plugin/css.js

@@ -0,0 +1,73 @@
+import { deepMerge } from '../internal/deepMerge.js';
+import { preset } from './preset-v2.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fsPromises from 'fs/promises';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function css(configuration) {
+    console.log('VALUE configuration', configuration);
+    console.log('configuration?.theme?.themes', configuration?.theme?.themes);
+    // states
+    const defaultTheme = configuration?.theme?.defaultTheme || preset.theme.defaultTheme;
+    const themesMerged = deepMerge(preset.theme.themes, configuration?.theme?.themes || {});
+    let response = '';
+    console.log('VALUE themesMerged', themesMerged);
+    for (const [name, values] of Object.entries(themesMerged)) {
+        let css = defaultTheme === name ? `:root,\n.${name} {\n` : `.${name} {\n`;
+        // ref
+        const ref = values?.dark ? preset.theme.themes.dark : preset.theme.themes.light;
+        // colors
+        css += `  color-scheme: ${values?.dark ? 'dark' : 'light'};\n`;
+        for (const [varName, varValue] of Object.entries(deepMerge(ref.colors, values?.colors) || {})) {
+            css += `  --system-${varName}: ${varValue};\n`;
+        }
+        // console.log('VALUE', values, deepMerge(values?.variables, ref.variables));
+        // variables
+        for (const [name, varValue] of Object.entries(deepMerge(ref.variables, values?.variables) || {})) {
+            css += `  --kit-${name}: ${varValue};\n`;
+        }
+        css += '}\n';
+        // console.log(`Themes colors (${name}):`, css);
+        response += css;
+    }
+    // console.log('All themes CSS:', response);
+    //typography
+    // states
+    const defaultTypography = configuration?.typography?.defaultTypography || preset.typography.defaultTypography;
+    for (const [name, values] of Object.entries(deepMerge(preset.typography.fonts, configuration?.typography?.fonts || {}))) {
+        let css = '';
+        css += defaultTypography === name ? `:root {\n` : `.${name} {\n`;
+        // fonts
+        for (const [fontName, fontValue] of Object.entries(values || {})) {
+            css += `  --kit-font-${fontName}: ${parser(fontValue)};\n`;
+        }
+        css += '}\n';
+        response += css;
+    }
+    //styles
+    response += `:root {\n`;
+    for (const [name, values] of Object.entries(deepMerge(preset.styles, configuration?.styles || {}))) {
+        let css = '';
+        if (values && typeof values === 'object') {
+            for (const [styleName, styleValue] of Object.entries(values || {})) {
+                css += `  --prism-${name}-${styleName}: ${parser(styleValue)};\n`;
+            }
+        }
+        else {
+            css += `  --prism-${name}: ${parser(values)};\n`;
+        }
+        response += css;
+    }
+    response += '}\n';
+    fsPromises.writeFile(path.resolve(__dirname, '../colors.css'), response);
+}
+const parser = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value;
+};

package/dist/plugin/preset-v2.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;
+        };
+    };
+};