lapikit 0.0.0-insiders.f0512a6 → 0.0.0-insiders.f248eb2

package/dist/components/textfield/textfield.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { getAssets } from '../../internal/index.js';
+	import { getAssets } from '../../internal/core/actions/assets.svelte.js';
 	import type { TextfieldProps } from './types.js';
 
 	//external
@@ -106,9 +106,9 @@
 		type === 'number' && hideSpinButtons && 'kit-textfield--hide-spin-buttons',
 		rest.class
 	]}
-	style:--base={assets.color(background)}
-	style:--on={assets.color(color)}
-	style:--shape={assets.shape(rounded)}
+	style:--textfield-background={assets.color(background)}
+	style:--textfield-color={assets.color(color)}
+	style:--textfield-shape={assets.shape(rounded)}
 >
 	{#if prepend}
 		<div class="kit-textfield-prepend">

package/dist/components/textfield/textfield.svelte.d.ts

@@ -1,4 +1,4 @@
 import type { TextfieldProps } from './types.js';
-declare const Textfield: import("svelte").Component<TextfieldProps, {}, "value" | "ref">;
+declare const Textfield: import("svelte").Component<TextfieldProps, {}, "ref" | "value">;
 type Textfield = ReturnType<typeof Textfield>;
 export default Textfield;

package/dist/components/textfield/types.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from '../../internal/types.js';
+import type { Component } from '../../internal/types/index.js';
 import type { Snippet } from 'svelte';
 export interface TextfieldProps extends Component {
     ref?: HTMLElement | null;

package/dist/components/toolbar/toolbar.css

@@ -1,75 +1,52 @@
 .kit-toolbar {
-	--toolbar-color: var(--on, var(--kit-on-surface));
-	--toolbar-background: var(--base, var(--kit-surface));
-	--toolbar-radius: var(--shape, var(--kit-radius-md));
-
 	display: flex;
 	align-items: center;
-	/* min-width: max-content; */
 	border-style: solid;
-	/* transition:
-		color 0.5s,
-		border-color 0.5s,
-		background-color 0.5s; */
-
 	border-width: 1px;
 	border-style: solid;
-	border-radius: var(--toolbar-radius);
-
-	/* theme */
-	color: var(--toolbar-color);
-	background-color: var(--toolbar-background);
-	border-color: var(--toolbar-background);
+	border-radius: var(--toolbar-shape, var(--system-shape-md));
+	color: var(--toolbar-color, var(--kit-label-primary));
+	background-color: var(--toolbar-background, var(--kit-background-grouped-tertiary));
+	border-color: var(--toolbar-background, var(--kit-background-grouped-tertiary));
 }
 
 /* density */
-.kit-toolbar[breakpoint]kit-toolbar--density-default {
-	border-radius: calc(var(--kit-spacing) * 2.25);
-}
 .kit-toolbar[breakpoint]kit-toolbar--density-default:not([class*='toolbar--orientation-vertical']) {
 	height: 3rem;
-	padding-inline: calc(var(--kit-spacing) * 1.5);
+	padding-inline: calc(var(--system-spacing) * 1.5);
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--density-default[class*='toolbar--orientation-vertical'] {
 	width: 3rem;
-	padding: calc(var(--kit-spacing) * 1.5) 0;
-}
-
-.kit-toolbar[breakpoint]kit-toolbar--density-compact {
-	border-radius: calc(var(--kit-spacing) * 1.75);
+	padding: calc(var(--system-spacing) * 1.5) 0;
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--density-compact:not([class*='toolbar--orientation-vertical']) {
 	height: 2.625rem;
-	padding-inline: calc(var(--kit-spacing) * 0.75);
+	padding-inline: calc(var(--system-spacing) * 0.75);
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--density-compact[class*='toolbar--orientation-vertical'] {
 	width: 2.625rem;
-	padding: calc(var(--kit-spacing) * 0.75) 0;
-}
-
-.kit-toolbar[breakpoint]kit-toolbar--density-comfortable {
-	border-radius: calc(var(--kit-spacing) * 3.5);
+	padding: calc(var(--system-spacing) * 0.75) 0;
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--density-comfortable:not(
 		[class*='toolbar--orientation-vertical']
 	) {
 	height: 3.5rem;
-	padding-inline: calc(var(--kit-spacing) * 2.25);
+	padding-inline: calc(var(--system-spacing) * 2.25);
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--density-comfortable[class*='toolbar--orientation-vertical'] {
 	width: 3.5rem;
-	padding: calc(var(--kit-spacing) * 2.25) 0;
+	padding: calc(var(--system-spacing) * 2.25) 0;
 }
 
 .kit-toolbar[breakpoint]kit-toolbar--variant-text,
 .kit-toolbar[breakpoint]kit-toolbar--variant-outline,
 .kit-toolbar[breakpoint]kit-toolbar--variant-dash {
-	--toolbar-color: var(--base, var(--kit-surface));
+	--toolbar-color: var(--base, var(--kit-background-grouped-primary));
 	background-color: transparent;
 }
 

package/dist/components/toolbar/toolbar.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { getAssets } from '../../internal/index.js';
+	import { getAssets } from '../../internal/core/actions/assets.svelte.js';
 	import type { ToolbarProps } from './types.js';
 
 	let {
@@ -37,9 +37,9 @@
 		location && assets.className('toolbar', 'location', location),
 		rest.class
 	]}
-	style:--base={assets.color(background)}
-	style:--on={assets.color(color)}
-	style:--shape={assets.shape(rounded)}
+	style:--toolbar-background={assets.color(background)}
+	style:--toolbar-color={assets.color(color)}
+	style:--toolbar-shape={assets.shape(rounded)}
 >
 	<div class={['kit-toolbar--wrapper', classContent]}>
 		{@render children?.()}

package/dist/components/toolbar/types.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from '../../internal/types.js';
+import type { Component } from '../../internal/types/index.js';
 type Variant = 'outline' | 'text' | 'dash';
 type Density = 'compact' | 'comfortable' | 'default';
 type Orientation = 'horizontal' | 'vertical';

package/dist/components/tooltip/tooltip.css

@@ -6,24 +6,16 @@
 }
 
 .kit-tooltip-content {
-	--tooltip-color: var(--on, var(--kit-on-surface));
-	--tooltip-background: var(--base, var(--kit-surface));
-	--tooltip-radius: var(--shape, var(--kit-radius-md));
-
-	background-color: var(--tooltip-background);
-	color: var(--tooltip-color);
-	border-radius: var(--tooltip-radius);
-	border: 1px solid var(--tooltip-background);
+	background-color: var(--tooltip-background, var(--kit-background-grouped-primary));
+	color: var(--tooltip-color, var(--kit-label-primary));
+	border-radius: var(--tooltip-shape, var(--system-shape-md));
+	border: 1px solid var(--tooltip-background, var(--kit-background-grouped-primary));
 	font-size: 0.875rem;
 	display: inline-block;
 	width: auto;
 	pointer-events: none;
 	overflow-wrap: break-word;
-	/* transition:
-		color 0.5s,
-		border-color 0.5s,
-		background-color 0.5s; */
-	box-shadow: 0px 16px 29px -10px color-mix(in oklab, var(--kit-scrim) 60%, transparent);
+	box-shadow: 0px 16px 29px -10px color-mix(in oklab, var(--kit-state-shadow) 60%, transparent);
 }
 
 /* density */

package/dist/components/tooltip/tooltip.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
-	import { getAssets } from '../../internal/assets.svelte.js';
-	import { getPositionsTooltip } from './tooltip.svelte.js';
+	import { getAssets } from '../../internal/core/actions/assets.svelte.js';
+	import { getPositionsTooltip } from '../../internal/core/actions/tooltip.svelte.js';
 	import type { PositionElement, TooltipProps } from './types.js';
 
 	let {
@@ -99,9 +99,9 @@
 				density && assets.className('tooltip-content', 'density', density),
 				rest.class
 			]}
-			style:--base={assets.color(background)}
-			style:--on={assets.color(color)}
-			style:--shape={assets.shape(rounded)}
+			style:--tooltip-background={assets.color(background)}
+			style:--tooltip-color={assets.color(color)}
+			style:--tooltip-shape={assets.shape(rounded)}
 		>
 			{#if tooltip}
 				{@render tooltip?.()}

package/dist/components/tooltip/types.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from '../../internal/types.js';
+import type { Component } from '../../internal/types/index.js';
 import type { Snippet } from 'svelte';
 export interface TooltipProps extends Component {
     open?: boolean;

package/dist/entry-bundler.d.ts

@@ -0,0 +1,12 @@
+type LapikitPreprocessOptions = {
+    plugins?: string[];
+};
+declare function lapikitPreprocess(options?: LapikitPreprocessOptions): {
+    markup({ content }: {
+        content: string;
+        filename?: string;
+    }): {
+        code: string;
+    } | undefined;
+};
+export { lapikitPreprocess };

package/dist/entry-bundler.js

@@ -0,0 +1,107 @@
+const components = ['btn'];
+function componentName(shortName) {
+    return 'Kit' + shortName.charAt(0).toUpperCase() + shortName.slice(1);
+}
+// plugins lapikit
+const lapikitPlugins = {
+    repl: {
+        components: ['repl'],
+        ref: '@lapikit/repl'
+    }
+};
+function lapikitPreprocess(options) {
+    return {
+        markup({ content }) {
+            const allComponents = [...components];
+            const componentToRef = new Map();
+            components.forEach((comp) => {
+                componentToRef.set(comp, 'lapikit/labs/components');
+            });
+            // plugins
+            if (options?.plugins) {
+                options.plugins.forEach((pluginKey) => {
+                    const plugin = lapikitPlugins[pluginKey];
+                    if (plugin) {
+                        plugin.components.forEach((comp) => {
+                            if (!allComponents.includes(comp)) {
+                                allComponents.push(comp);
+                            }
+                            componentToRef.set(comp, plugin.ref);
+                        });
+                    }
+                });
+            }
+            const hasComponent = allComponents.some((comp) => content.includes(`<kit:${comp}`));
+            if (!hasComponent)
+                return;
+            let processedContent = content;
+            const importedComponents = new Map();
+            let hasChanges = true;
+            while (hasChanges) {
+                hasChanges = false;
+                for (const shortName of allComponents) {
+                    const componentNameStr = componentName(shortName);
+                    const attrPattern = `(?:[^>"']|"[^"]*"|'[^']*')*?`;
+                    const selfClosingRegex = new RegExp(`<kit:${shortName}(${attrPattern})\\s*/>`, 'g');
+                    const pairRegex = new RegExp(`<kit:${shortName}(${attrPattern})>([\\s\\S]*?)<\\/kit:${shortName}\\s*>`, 'g');
+                    let newContent = processedContent.replace(selfClosingRegex, (fullMatch, attrs) => {
+                        hasChanges = true;
+                        const ref = componentToRef.get(shortName) || 'lapikit/labs/components';
+                        importedComponents.set(componentNameStr, ref);
+                        return `<${componentNameStr}${attrs} />`;
+                    });
+                    newContent = newContent.replace(pairRegex, (fullMatch, attrs, children) => {
+                        hasChanges = true;
+                        const ref = componentToRef.get(shortName) || 'lapikit/labs/components';
+                        importedComponents.set(componentNameStr, ref);
+                        return `<${componentNameStr}${attrs}>${children}</${componentNameStr}>`;
+                    });
+                    if (newContent !== processedContent) {
+                        processedContent = newContent;
+                    }
+                }
+            }
+            if (processedContent === content)
+                return;
+            if (importedComponents.size > 0) {
+                const importsByRef = new Map();
+                importedComponents.forEach((ref, component) => {
+                    if (!importsByRef.has(ref)) {
+                        importsByRef.set(ref, []);
+                    }
+                    importsByRef.get(ref).push(component);
+                });
+                const importLines = Array.from(importsByRef.entries())
+                    .map(([ref, components]) => {
+                    const imports = components.join(', ');
+                    return `\n\timport { ${imports} } from '${ref}';`;
+                })
+                    .join('');
+                const scriptRegex = /<script(?![^>]*\bmodule\b)([^>]*)>/;
+                const scriptMatch = processedContent.match(scriptRegex);
+                if (scriptMatch && scriptMatch.index !== undefined) {
+                    const insertPos = scriptMatch.index + scriptMatch[0].length;
+                    processedContent =
+                        processedContent.slice(0, insertPos) + importLines + processedContent.slice(insertPos);
+                }
+                else {
+                    const moduleScriptMatch = processedContent.match(/<script[^>]*\bmodule\b[^>]*>/);
+                    if (moduleScriptMatch && moduleScriptMatch.index !== undefined) {
+                        const moduleScriptEnd = processedContent.indexOf('</script>', moduleScriptMatch.index) + '</script>'.length;
+                        processedContent =
+                            processedContent.slice(0, moduleScriptEnd) +
+                                `\n\n<script>${importLines}\n</script>` +
+                                processedContent.slice(moduleScriptEnd);
+                    }
+                    else {
+                        processedContent = `<script>${importLines}\n</script>\n\n` + processedContent;
+                    }
+                }
+            }
+            return {
+                code: processedContent
+            };
+        }
+    };
+}
+export { lapikitPreprocess };

package/dist/index.d.ts

@@ -1,27 +1,3 @@
-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;
+import type { LapikitConfiguration } from './internal/types/configuration.js';
+declare function createLapikit(lapikit: LapikitConfiguration): void;
 export default createLapikit;

package/dist/index.js

@@ -1,17 +1,14 @@
-import { deepMerge } from './internal/deepMerge.js';
+import { deepMerge } from './internal/helpers/deep-merge.js';
 import { breakpoints } from './stores/breakpoints.js';
 import { get } from 'svelte/store';
-import { valueToPx } from './utils/convert.js';
 import { devices } from './stores/devices.js';
+import { valueToPx } from './internal/helpers/convert.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);
@@ -22,7 +19,6 @@ function createLapikit(lapikit) {
             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,149 @@
+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;
+        colorScheme: boolean;
+        themes: {
+            light: {
+                dark: boolean;
+                colors: {
+                    label: {
+                        primary: string;
+                        secondary: string;
+                        tertiary: string;
+                        quaternary: string;
+                    };
+                    accent: {
+                        primary: string;
+                        success: string;
+                        warning: string;
+                        destructive: string;
+                        info: string;
+                    };
+                    separator: {
+                        default: string;
+                        opaque: string;
+                    };
+                    state: {
+                        placeholder: string;
+                        disabled: string;
+                        link: string;
+                        highlight: string;
+                        shadow: string;
+                    };
+                    background: {
+                        primary: string;
+                        secondary: string;
+                        tertiary: string;
+                        grouped: {
+                            primary: string;
+                            secondary: string;
+                            tertiary: string;
+                        };
+                    };
+                };
+                variables: {
+                    'test-variable': string;
+                };
+            };
+            dark: {
+                dark: boolean;
+                colors: {
+                    pink: string;
+                    label: {
+                        primary: string;
+                        secondary: string;
+                        tertiary: string;
+                        quaternary: string;
+                    };
+                    accent: {
+                        primary: string;
+                        success: string;
+                        warning: string;
+                        destructive: string;
+                        info: string;
+                    };
+                    separator: {
+                        default: string;
+                        opaque: string;
+                    };
+                    state: {
+                        placeholder: string;
+                        disabled: string;
+                        link: string;
+                        highlight: string;
+                        shadow: string;
+                    };
+                    background: {
+                        primary: string;
+                        secondary: string;
+                        tertiary: string;
+                        grouped: {
+                            primary: string;
+                            secondary: string;
+                            tertiary: string;
+                        };
+                    };
+                };
+                variables: {
+                    'test-variable': 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;
+        };
+        dialog: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+        };
+        modal: {
+            xs: string;
+            sm: string;
+            md: string;
+            lg: string;
+            xl: string;
+        };
+        animation: {
+            'ripple-duration': string;
+        };
+    };
+};