lapikit 0.0.0-insiders.e877f7f → 0.0.0-insiders.f0512a6

package/dist/components/toolbar/toolbar.css

@@ -0,0 +1,129 @@
+.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);
+}
+
+/* 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);
+}
+
+.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);
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--density-compact:not([class*='toolbar--orientation-vertical']) {
+	height: 2.625rem;
+	padding-inline: calc(var(--kit-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);
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--density-comfortable:not(
+		[class*='toolbar--orientation-vertical']
+	) {
+	height: 3.5rem;
+	padding-inline: calc(var(--kit-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;
+}
+
+.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));
+	background-color: transparent;
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--variant-outline {
+	border-color: currentColor;
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--variant-dash {
+	border-style: dashed;
+	border-color: currentColor;
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--orientation-horizontal {
+	flex-direction: row;
+	width: 100%;
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--orientation-vertical {
+	flex-direction: column;
+	min-height: fit-content;
+	width: fit-content;
+}
+
+/* wrapper */
+.kit-toolbar .kit-toolbar--wrapper {
+	display: flex;
+	align-items: center;
+	/* margin-left: auto;
+	margin-right: auto; */
+	flex-direction: row;
+	height: auto;
+	width: 100%;
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--orientation-vertical .kit-toolbar--wrapper {
+	flex-direction: column;
+	height: 100%;
+}
+
+/* location */
+.kit-toolbar[breakpoint]kit-toolbar--location-top {
+	top: 0px;
+	z-index: 1004;
+	transform: translateY(0px);
+	position: fixed;
+	left: 0px;
+	width: calc(100% + 0px);
+}
+
+.kit-toolbar[breakpoint]kit-toolbar--location-bottom {
+	z-index: 1004;
+	transform: translateY(0px);
+	position: fixed;
+	left: 0px;
+	width: calc(100% + 0px);
+	bottom: 0px;
+}

package/dist/components/toolbar/toolbar.svelte

@@ -0,0 +1,47 @@
+<script lang="ts">
+	import { getAssets } from '../../internal/index.js';
+	import type { ToolbarProps } from './types.js';
+
+	let {
+		children,
+		ref = $bindable(),
+		is = 'div',
+		classContent,
+		light,
+		dark,
+		variant,
+		rounded,
+		background,
+		color,
+		density = 'default',
+		orientation = 'horizontal',
+		location,
+		...rest
+	}: ToolbarProps = $props();
+
+	const assets = getAssets();
+</script>
+
+<svelte:element
+	this={is}
+	bind:this={ref}
+	{...rest}
+	role="toolbar"
+	class={[
+		'kit-toolbar',
+		light && 'light',
+		dark && 'dark',
+		variant && assets.className('toolbar', 'variant', variant),
+		density && assets.className('toolbar', 'density', density),
+		orientation && assets.className('toolbar', 'orientation', orientation),
+		location && assets.className('toolbar', 'location', location),
+		rest.class
+	]}
+	style:--base={assets.color(background)}
+	style:--on={assets.color(color)}
+	style:--shape={assets.shape(rounded)}
+>
+	<div class={['kit-toolbar--wrapper', classContent]}>
+		{@render children?.()}
+	</div>
+</svelte:element>

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

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

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

@@ -0,0 +1,27 @@
+import type { Component } from '../../internal/types.js';
+type Variant = 'outline' | 'text' | 'dash';
+type Density = 'compact' | 'comfortable' | 'default';
+type Orientation = 'horizontal' | 'vertical';
+type Location = 'top' | 'bottom';
+export interface ToolbarProps extends Component {
+    is?: 'div' | 'header' | 'nav';
+    variant?: Variant | {
+        [key: string]: Variant;
+    };
+    rounded?: string;
+    density?: Density | {
+        [key: string]: Density;
+    };
+    dark?: boolean;
+    light?: boolean;
+    color?: string;
+    orientation?: Orientation | {
+        [key: string]: Orientation;
+    };
+    background?: string;
+    location?: Location | {
+        [key: string]: Location;
+    };
+    classContent?: string | string[] | undefined;
+}
+export {};

package/dist/components/toolbar/types.js

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

package/dist/components/tooltip/tooltip.css

@@ -6,8 +6,8 @@
 }
 
 .kit-tooltip-content {
-	--tooltip-color: var(--on, var(--kit-on-neutral));
-	--tooltip-background: var(--base, var(--kit-neutral));
+	--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);
@@ -19,10 +19,10 @@
 	width: auto;
 	pointer-events: none;
 	overflow-wrap: break-word;
-	transition:
+	/* transition:
 		color 0.5s,
 		border-color 0.5s,
-		background-color 0.5s;
+		background-color 0.5s; */
 	box-shadow: 0px 16px 29px -10px color-mix(in oklab, var(--kit-scrim) 60%, transparent);
 }
 

package/dist/index.d.ts

@@ -1 +1,27 @@
-export declare function helloWorld(): void;
+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,4 +1,28 @@
-// Reexport your entry components here
-export function helloWorld() {
-    console.log('Hello world, this is lapikit!');
+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/assets.svelte.d.ts

@@ -4,4 +4,5 @@ export declare function getAssets(): {
         [key: string]: string;
     }): string | undefined;
     color(color?: string): string | undefined;
+    unit(value?: string | number): string | undefined;
 };

package/dist/internal/assets.svelte.js

@@ -34,8 +34,21 @@ export function getAssets() {
                     color.includes('oklch') ||
                     x11ColorNames.includes(color.toLowerCase()))
                     return color;
+                if (color.includes('transparent') || color.includes('inherit') || color.includes('initial'))
+                    return color;
                 return `var(--kit-${color})`;
             }
+        },
+        unit(value) {
+            if (typeof value === 'number')
+                return `${value}px`;
+            if (typeof value === 'string') {
+                const cleaned = value.trim();
+                const isOnlyNumericLike = /^[\d.,]+$/.test(cleaned);
+                if (isOnlyNumericLike)
+                    return `${value}px`;
+            }
+            return value;
         }
     };
 }

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

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

@@ -1,3 +1,4 @@
 export * from './terminal.js';
 export * from './ansi.js';
 export * from './assets.svelte.js';
+export * from './scroll.js';

package/dist/internal/index.js

@@ -1,3 +1,4 @@
 export * from './terminal.js';
 export * from './ansi.js';
 export * from './assets.svelte.js';
+export * from './scroll.js';

package/dist/internal/ripple.d.ts

@@ -0,0 +1,12 @@
+interface RippleOptions {
+    component?: string;
+    center?: boolean;
+    color?: string;
+    duration?: number;
+    disabled?: boolean;
+}
+export declare function ripple(el: HTMLElement, options?: RippleOptions): {
+    destroy(): void;
+    update(newOptions: RippleOptions): void;
+};
+export {};

package/dist/internal/ripple.js

@@ -0,0 +1,93 @@
+const triggerEvents = ['pointerdown', 'touchstart', 'keydown'];
+const cancelEvents = ['mouseleave', 'dragleave', 'touchmove', 'touchcancel', 'pointerup', 'keyup'];
+export function ripple(el, options = {}) {
+    const rippleContainer = document.createElement('div');
+    addClasses();
+    setOptions(options);
+    function addClasses(center) {
+        const shouldBeCentered = center || options.center;
+        if (!rippleContainer.classList.contains('kit-ripple--effect')) {
+            rippleContainer.classList.add('kit-ripple--effect');
+        }
+        if (!shouldBeCentered && rippleContainer.classList.contains('kit-ripple--center')) {
+            rippleContainer.classList.remove('kit-ripple--center');
+        }
+        if (shouldBeCentered) {
+            rippleContainer.classList.add('kit-ripple--center');
+        }
+    }
+    function setOptions(options) {
+        if (options.disabled || el.hasAttribute('aria-disabled')) {
+            rippleContainer.remove();
+        }
+        else {
+            el.appendChild(rippleContainer);
+        }
+        if (options.duration && options.duration < 0) {
+            options.duration = undefined;
+        }
+        if (options.component) {
+            rippleContainer.style.setProperty('--ripple-radius', `var(--${options.component}-radius)`);
+        }
+        if (options.color) {
+            rippleContainer.style.setProperty('--ripple-color', options.color);
+        }
+        if (options.duration) {
+            rippleContainer.style.setProperty('--ripple-duration', `${options.duration}ms`);
+        }
+    }
+    function createRipple(e, center) {
+        if (options.disabled || el.hasAttribute('aria-disabled')) {
+            return;
+        }
+        if (e instanceof KeyboardEvent) {
+            if (!['Enter', 'Space'].includes(e.code) || e.repeat) {
+                return;
+            }
+            e.preventDefault();
+            const click = new PointerEvent('pointerdown');
+            createRipple(click, true);
+            return;
+        }
+        addClasses(center);
+        const rect = el.getBoundingClientRect();
+        const clientX = window.TouchEvent && e instanceof TouchEvent
+            ? e.touches[0].clientX
+            : e.clientX;
+        const clientY = window.TouchEvent && e instanceof TouchEvent
+            ? e.touches[0].clientY
+            : e.clientY;
+        const x = clientX - rect.left > el.offsetWidth / 2 ? 0 : el.offsetWidth;
+        const y = clientY - rect.top > el.offsetHeight / 2 ? 0 : el.offsetHeight;
+        const radius = Math.hypot(x - (clientX - rect.left), y - (clientY - rect.top));
+        const ripple = document.createElement('div');
+        ripple.classList.add('kit-ripple');
+        ripple.style.left = `${clientX - rect.left - radius}px`;
+        ripple.style.top = `${clientY - rect.top - radius}px`;
+        ripple.style.width = ripple.style.height = `${radius * 2}px`;
+        rippleContainer.appendChild(ripple);
+        function removeRipple() {
+            if (ripple === null) {
+                return;
+            }
+            ripple.style.opacity = '0';
+            setTimeout(() => {
+                ripple.remove();
+            }, options.duration || 1000);
+            cancelEvents.forEach((event) => el.removeEventListener(event, removeRipple));
+        }
+        cancelEvents.forEach((event) => el.addEventListener(event, removeRipple, { passive: true }));
+    }
+    triggerEvents.forEach((event) => el.addEventListener(event, createRipple, { passive: event === 'touchstart' }));
+    return {
+        destroy() {
+            triggerEvents.forEach((event) => {
+                el.removeEventListener(event, createRipple);
+            });
+        },
+        update(newOptions) {
+            options = newOptions;
+            setOptions(newOptions);
+        }
+    };
+}

package/dist/internal/scroll.d.ts

@@ -0,0 +1 @@
+export declare function disabledScroll(state: boolean): void;

package/dist/internal/scroll.js

@@ -0,0 +1,6 @@
+import { BROWSER } from 'esm-env';
+export function disabledScroll(state) {
+    if (BROWSER) {
+        document.body.style.overflow = state ? 'hidden' : '';
+    }
+}

package/dist/internal/unit.d.ts

@@ -0,0 +1 @@
+export declare const setUnit: (value: string | number) => string;

package/dist/internal/unit.js

@@ -0,0 +1,11 @@
+export const setUnit = (value) => {
+    if (typeof value === 'number')
+        return `${value}px`;
+    if (typeof value === 'string') {
+        const cleaned = value.trim();
+        const isOnlyNumericLike = /^[\d.,]+$/.test(cleaned);
+        if (isOnlyNumericLike)
+            return `${value}px`;
+    }
+    return value;
+};

package/dist/plugin/vitejs.d.ts

@@ -1,6 +1,11 @@
 import type { ViteDevServer } from 'vite';
-export declare function lapikit(): Promise<{
+type Lapikit = {
+    minify?: boolean;
+    config?: string;
+};
+export declare function lapikit({ minify, config }?: Lapikit): Promise<{
     name: string;
     configResolved(): Promise<void>;
     configureServer(server: ViteDevServer): Promise<void>;
 }>;
+export {};

package/dist/plugin/vitejs.js

@@ -2,21 +2,26 @@ import { importer } from './modules/importer.js';
 import { processCSS } from '../style/css.js';
 import { parseConfig } from './modules/config.js';
 import { terminal } from '../internal/terminal.js';
-export async function lapikit() {
+import path from 'path';
+import fs from 'fs';
+const app = process.cwd();
+export async function lapikit({ minify = false, config = 'src/plugins/lapikit.js' } = {}) {
+    const pathConfig = path.resolve(app, config);
+    console.log('pathConfig:', pathConfig);
     return {
         name: 'lapikit/vite.js',
         async configResolved() {
-            const config = await importer();
-            const result = await parseConfig(config);
+            const importedConfig = await importer();
+            const result = await parseConfig(importedConfig);
             await processCSS(result);
             terminal('info', 'lapikit is up!');
         },
         async configureServer(server) {
-            server.watcher.add('./lapikit.config.js');
+            server.watcher.add(config);
             server.watcher.on('change', async (filePath) => {
-                if (String(filePath).includes('lapikit.config.js')) {
-                    const config = await importer();
-                    const result = await parseConfig(config);
+                if (String(filePath).includes(config)) {
+                    const importedConfig = await importer();
+                    const result = await parseConfig(importedConfig);
                     await processCSS(result);
                     terminal('info', 'lapikit config reloaded');
                 }

package/dist/preset.js

@@ -4,7 +4,7 @@ export const config = {
         minify: false // true | false
     },
     theme: {
-        colorScheme: 'dark', // 'light' | 'dark' | 'auto'
+        colorScheme: 'system', // 'light' | 'dark' | 'system'
         colors: {
             primary: { light: 'oklch(45% 0.24 277.023)', dark: 'oklch(45% 0.24 277.023)' },
             'on-primary': { light: 'oklch(14% 0.005 285.823)', dark: 'oklch(14% 0.005 285.823)' },
@@ -35,7 +35,7 @@ export const config = {
     breakpoints: {
         mobileBreakpoint: 'sm',
         tabletBreakpoint: 'md',
-        laptopBreakpoint: 'xl',
+        laptopBreakpoint: 'lg',
         thresholds: {
             _default: 0, // 0px
             xs: '28rem', //448px

package/dist/stores/breakpoints.d.ts

@@ -0,0 +1,6 @@
+import { type Writable } from 'svelte/store';
+type Breakpoints = {
+    [key: string]: number;
+};
+export declare const breakpoints: Writable<Breakpoints>;
+export {};