sdocs 0.0.21 → 0.0.23

package/dist/client/App.svelte.d.ts

@@ -1,14 +1,15 @@
-import type { DocEntry } from '../types.js';
+import { SvelteComponentTyped } from "svelte";
 import '../ui/styles/sdocs.css';
-interface Props {
-    docs: DocEntry[];
-    logo?: string;
-    cssNames?: string[];
-    sidebarConfig?: {
-        order?: Record<string, string[]>;
-        open?: string[];
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
     };
+    slots: {};
+};
+export type AppProps = typeof __propDef.props;
+export type AppEvents = typeof __propDef.events;
+export type AppSlots = typeof __propDef.slots;
+export default class App extends SvelteComponentTyped<AppProps, AppEvents, AppSlots> {
 }
-declare const App: import("svelte").Component<Props, {}, "">;
-type App = ReturnType<typeof App>;
-export default App;
+export {};

package/dist/client/views/CollapsiblePanel.svelte.d.ts

@@ -1,9 +1,14 @@
-import type { Snippet } from 'svelte';
-interface Props {
-    title: string;
-    defaultExpanded?: boolean;
-    children: Snippet;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type CollapsiblePanelProps = typeof __propDef.props;
+export type CollapsiblePanelEvents = typeof __propDef.events;
+export type CollapsiblePanelSlots = typeof __propDef.slots;
+export default class CollapsiblePanel extends SvelteComponentTyped<CollapsiblePanelProps, CollapsiblePanelEvents, CollapsiblePanelSlots> {
 }
-declare const CollapsiblePanel: import("svelte").Component<Props, {}, "">;
-type CollapsiblePanel = ReturnType<typeof CollapsiblePanel>;
-export default CollapsiblePanel;
+export {};

package/dist/client/views/ComponentView.svelte.d.ts

@@ -1,10 +1,14 @@
-import type { DocEntry } from '../../types.js';
-interface Props {
-    doc: DocEntry;
-    /** If set, show only this example (full-page view) */
-    snippetName?: string;
-    activeStylesheet?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ComponentViewProps = typeof __propDef.props;
+export type ComponentViewEvents = typeof __propDef.events;
+export type ComponentViewSlots = typeof __propDef.slots;
+export default class ComponentView extends SvelteComponentTyped<ComponentViewProps, ComponentViewEvents, ComponentViewSlots> {
 }
-declare const ComponentView: import("svelte").Component<Props, {}, "">;
-type ComponentView = ReturnType<typeof ComponentView>;
-export default ComponentView;
+export {};

package/dist/client/views/ControlsPanel.svelte.d.ts

@@ -1,13 +1,14 @@
-import type { ParsedProp, ParsedCssProp } from '../../types.js';
-interface Props {
-    componentProps: ParsedProp[];
-    cssProps: ParsedCssProp[];
-    propValues: Record<string, unknown>;
-    cssValues: Record<string, string>;
-    onPropChange: (name: string, value: unknown) => void;
-    onCssChange: (name: string, value: string) => void;
-    onReset: () => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ControlsPanelProps = typeof __propDef.props;
+export type ControlsPanelEvents = typeof __propDef.events;
+export type ControlsPanelSlots = typeof __propDef.slots;
+export default class ControlsPanel extends SvelteComponentTyped<ControlsPanelProps, ControlsPanelEvents, ControlsPanelSlots> {
 }
-declare const ControlsPanel: import("svelte").Component<Props, {}, "">;
-type ControlsPanel = ReturnType<typeof ControlsPanel>;
-export default ControlsPanel;
+export {};

package/dist/client/views/DataTable.svelte.d.ts

@@ -1,11 +1,14 @@
-interface Column {
-    key: string;
-    label: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type DataTableProps = typeof __propDef.props;
+export type DataTableEvents = typeof __propDef.events;
+export type DataTableSlots = typeof __propDef.slots;
+export default class DataTable extends SvelteComponentTyped<DataTableProps, DataTableEvents, DataTableSlots> {
 }
-interface Props {
-    columns: Column[];
-    rows: Record<string, unknown>[];
-}
-declare const DataTable: import("svelte").Component<Props, {}, "">;
-type DataTable = ReturnType<typeof DataTable>;
-export default DataTable;
+export {};

package/dist/client/views/HomePage.svelte.d.ts

@@ -1,8 +1,14 @@
-import type { DocEntry } from '../../types.js';
-interface Props {
-    docs: DocEntry[];
-    logo: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type HomePageProps = typeof __propDef.props;
+export type HomePageEvents = typeof __propDef.events;
+export type HomePageSlots = typeof __propDef.slots;
+export default class HomePage extends SvelteComponentTyped<HomePageProps, HomePageEvents, HomePageSlots> {
 }
-declare const HomePage: import("svelte").Component<Props, {}, "">;
-type HomePage = ReturnType<typeof HomePage>;
-export default HomePage;
+export {};

package/dist/client/views/LayoutView.svelte.d.ts

@@ -1,8 +1,14 @@
-import type { DocEntry } from '../../types.js';
-interface Props {
-    doc: DocEntry;
-    activeStylesheet?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type LayoutViewProps = typeof __propDef.props;
+export type LayoutViewEvents = typeof __propDef.events;
+export type LayoutViewSlots = typeof __propDef.slots;
+export default class LayoutView extends SvelteComponentTyped<LayoutViewProps, LayoutViewEvents, LayoutViewSlots> {
 }
-declare const LayoutView: import("svelte").Component<Props, {}, "">;
-type LayoutView = ReturnType<typeof LayoutView>;
-export default LayoutView;
+export {};

package/dist/client/views/PageView.svelte.d.ts

@@ -1,8 +1,14 @@
-import type { DocEntry } from '../../types.js';
-interface Props {
-    doc: DocEntry;
-    activeStylesheet?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type PageViewProps = typeof __propDef.props;
+export type PageViewEvents = typeof __propDef.events;
+export type PageViewSlots = typeof __propDef.slots;
+export default class PageView extends SvelteComponentTyped<PageViewProps, PageViewEvents, PageViewSlots> {
 }
-declare const PageView: import("svelte").Component<Props, {}, "">;
-type PageView = ReturnType<typeof PageView>;
-export default PageView;
+export {};

package/dist/client/views/PreviewFrame.svelte.d.ts

@@ -1,10 +1,14 @@
-interface Props {
-    src: string;
-    props?: Record<string, unknown>;
-    cssVars?: Record<string, string>;
-    activeStylesheet?: string;
-    fullHeight?: boolean;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type PreviewFrameProps = typeof __propDef.props;
+export type PreviewFrameEvents = typeof __propDef.events;
+export type PreviewFrameSlots = typeof __propDef.slots;
+export default class PreviewFrame extends SvelteComponentTyped<PreviewFrameProps, PreviewFrameEvents, PreviewFrameSlots> {
 }
-declare const PreviewFrame: import("svelte").Component<Props, {}, "">;
-type PreviewFrame = ReturnType<typeof PreviewFrame>;
-export default PreviewFrame;
+export {};

package/dist/client/views/Sidebar.svelte.d.ts

@@ -1,16 +1,14 @@
-import type { TreeNode } from '../tree-builder.js';
-type ThemeMode = 'light' | 'dark';
-interface Props {
-    tree: TreeNode[];
-    currentPath: string[];
-    logo: string;
-    cssNames?: string[];
-    activeStylesheet?: string;
-    theme?: ThemeMode;
-    onToggleFullscreen?: () => void;
-    onStylesheetChange?: (name: string) => void;
-    onThemeChange?: (theme: ThemeMode) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type SidebarProps = typeof __propDef.props;
+export type SidebarEvents = typeof __propDef.events;
+export type SidebarSlots = typeof __propDef.slots;
+export default class Sidebar extends SvelteComponentTyped<SidebarProps, SidebarEvents, SidebarSlots> {
 }
-declare const Sidebar: import("svelte").Component<Props, {}, "">;
-type Sidebar = ReturnType<typeof Sidebar>;
-export default Sidebar;
+export {};

package/dist/server/config.d.ts

@@ -1,7 +1,11 @@
 import type { SdocsConfig, ResolvedSdocsConfig } from '../types.js';
 /** Find the config file path in the given directory */
 export declare function findConfigFile(root: string): string | null;
+/** Load the raw config from file (unresolved) */
+export declare function loadRawConfig(root: string): Promise<SdocsConfig>;
 /** Load and resolve the sdocs config with defaults */
 export declare function loadConfig(root: string): Promise<ResolvedSdocsConfig>;
+/** Resolve config and finalize paths */
+export declare function resolveAndFinalize(userConfig: SdocsConfig, root: string): ResolvedSdocsConfig;
 /** Merge user config with defaults */
 export declare function resolveConfig(userConfig: SdocsConfig): ResolvedSdocsConfig;

package/dist/server/config.js

@@ -39,12 +39,20 @@ function resolveCssPaths(css, root) {
     }
     return resolved;
 }
-/** Load and resolve the sdocs config with defaults */
-export async function loadConfig(root) {
+/** Load the raw config from file (unresolved) */
+export async function loadRawConfig(root) {
     const configPath = findConfigFile(root);
     if (!configPath)
-        return { ...DEFAULTS };
-    const userConfig = await importConfig(configPath);
+        return {};
+    return importConfig(configPath);
+}
+/** Load and resolve the sdocs config with defaults */
+export async function loadConfig(root) {
+    const rawConfig = await loadRawConfig(root);
+    return resolveAndFinalize(rawConfig, root);
+}
+/** Resolve config and finalize paths */
+export function resolveAndFinalize(userConfig, root) {
     const resolved = resolveConfig(userConfig);
     resolved.include = resolveIncludePatterns(resolved.include, root);
     resolved.css = resolveCssPaths(resolved.css, root);

package/dist/ui/Button/Button.svelte.d.ts

@@ -1,27 +1,14 @@
-import type { Snippet } from 'svelte';
-/**
- * @cssvar {shorthand} --p - Padding
- * @cssvar {length} --r - Border radius
- * @cssvar {length} --h - Height
- * @cssvar {length} --gap - Gap between left, label, right
- * @cssvar {color} --bg - Background color
- * @cssvar {color} --bg-hover - Background on hover
- * @cssvar {color} --bg-active - Background when pressed
- * @cssvar {color} --border - Border color
- * @cssvar {color} --color - Text/icon color
- * @cssvar {color} --color-hover - Text/icon color on hover
- * @cssvar {string} --font-weight - Font weight
- * @cssvar {length} --font-size - Font size
- */
-interface Props {
-    onclick?: (e: MouseEvent) => void;
-    title?: string;
-    disabled?: boolean;
-    left?: Snippet;
-    right?: Snippet;
-    children?: Snippet;
-    class?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ButtonProps = typeof __propDef.props;
+export type ButtonEvents = typeof __propDef.events;
+export type ButtonSlots = typeof __propDef.slots;
+export default class Button extends SvelteComponentTyped<ButtonProps, ButtonEvents, ButtonSlots> {
 }
-declare const Button: import("svelte").Component<Props, {}, "">;
-type Button = ReturnType<typeof Button>;
-export default Button;
+export {};

package/dist/ui/Control/Checkbox.svelte.d.ts

@@ -1,8 +1,14 @@
-interface Props {
-    label: string;
-    value: boolean;
-    onchange: (value: boolean) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type CheckboxProps = typeof __propDef.props;
+export type CheckboxEvents = typeof __propDef.events;
+export type CheckboxSlots = typeof __propDef.slots;
+export default class Checkbox extends SvelteComponentTyped<CheckboxProps, CheckboxEvents, CheckboxSlots> {
 }
-declare const Checkbox: import("svelte").Component<Props, {}, "">;
-type Checkbox = ReturnType<typeof Checkbox>;
-export default Checkbox;
+export {};

package/dist/ui/Control/Color.svelte.d.ts

@@ -1,8 +1,14 @@
-interface Props {
-    label: string;
-    value: string;
-    onchange: (value: string) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ColorProps = typeof __propDef.props;
+export type ColorEvents = typeof __propDef.events;
+export type ColorSlots = typeof __propDef.slots;
+export default class Color extends SvelteComponentTyped<ColorProps, ColorEvents, ColorSlots> {
 }
-declare const Color: import("svelte").Component<Props, {}, "">;
-type Color = ReturnType<typeof Color>;
-export default Color;
+export {};

package/dist/ui/Control/Dimension.svelte.d.ts

@@ -1,8 +1,14 @@
-interface Props {
-    label: string;
-    value: string;
-    onchange: (value: string) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type DimensionProps = typeof __propDef.props;
+export type DimensionEvents = typeof __propDef.events;
+export type DimensionSlots = typeof __propDef.slots;
+export default class Dimension extends SvelteComponentTyped<DimensionProps, DimensionEvents, DimensionSlots> {
 }
-declare const Dimension: import("svelte").Component<Props, {}, "">;
-type Dimension = ReturnType<typeof Dimension>;
-export default Dimension;
+export {};

package/dist/ui/Control/Number.svelte.d.ts

@@ -1,8 +1,14 @@
-interface Props {
-    label: string;
-    value: number;
-    onchange: (value: number) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type NumberProps = typeof __propDef.props;
+export type NumberEvents = typeof __propDef.events;
+export type NumberSlots = typeof __propDef.slots;
+export default class Number extends SvelteComponentTyped<NumberProps, NumberEvents, NumberSlots> {
 }
-declare const Number: import("svelte").Component<Props, {}, "">;
-type Number = ReturnType<typeof Number>;
-export default Number;
+export {};

package/dist/ui/Control/Select.svelte.d.ts

@@ -1,9 +1,14 @@
-interface Props {
-    label: string;
-    value: string;
-    options: string[];
-    onchange: (value: string) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type SelectProps = typeof __propDef.props;
+export type SelectEvents = typeof __propDef.events;
+export type SelectSlots = typeof __propDef.slots;
+export default class Select extends SvelteComponentTyped<SelectProps, SelectEvents, SelectSlots> {
 }
-declare const Select: import("svelte").Component<Props, {}, "">;
-type Select = ReturnType<typeof Select>;
-export default Select;
+export {};

package/dist/ui/Control/Text.svelte.d.ts

@@ -1,8 +1,14 @@
-interface Props {
-    label: string;
-    value: string;
-    onchange: (value: string) => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TextProps = typeof __propDef.props;
+export type TextEvents = typeof __propDef.events;
+export type TextSlots = typeof __propDef.slots;
+export default class Text extends SvelteComponentTyped<TextProps, TextEvents, TextSlots> {
 }
-declare const Text: import("svelte").Component<Props, {}, "">;
-type Text = ReturnType<typeof Text>;
-export default Text;
+export {};

package/dist/ui/Frame/Frame.svelte.d.ts

@@ -1,15 +1,14 @@
-import type { Snippet } from 'svelte';
-/**
- * A flexible layout component with slots for top, bottom, left, right, and center content.
- */
-interface Props {
-    top?: Snippet;
-    bottom?: Snippet;
-    left?: Snippet;
-    right?: Snippet;
-    children?: Snippet;
-    class?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FrameProps = typeof __propDef.props;
+export type FrameEvents = typeof __propDef.events;
+export type FrameSlots = typeof __propDef.slots;
+export default class Frame extends SvelteComponentTyped<FrameProps, FrameEvents, FrameSlots> {
 }
-declare const Frame: import("svelte").Component<Props, {}, "">;
-type Frame = ReturnType<typeof Frame>;
-export default Frame;
+export {};

package/dist/ui/Icon/Icon.svelte.d.ts

@@ -1,16 +1,16 @@
-/**
- * @cssvar {length} --w - Icon width (default: 24px)
- * @cssvar {length} --h - Icon height (default: 24px)
- * @cssvar {color} --fill - Icon color, inherited via currentColor (default: currentColor)
- */
-interface Props {
-    /** Icon name matching a filename in the icons folder (e.g. "chevron-right") */
-    name: string;
-    /** Additional CSS class names */
-    class?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        icons?: Record<string, string>;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type IconProps = typeof __propDef.props;
+export type IconEvents = typeof __propDef.events;
+export type IconSlots = typeof __propDef.slots;
+export default class Icon extends SvelteComponentTyped<IconProps, IconEvents, IconSlots> {
 }
-declare const Icon: import("svelte").Component<Props, {
-    icons: Record<string, string>;
-}, "">;
-type Icon = ReturnType<typeof Icon>;
-export default Icon;
+export {};

package/dist/ui/NavTree/Group.svelte.d.ts

@@ -1,11 +1,14 @@
-import type { Snippet } from 'svelte';
-interface Props {
-    label: string;
-    expanded?: boolean;
-    children?: Snippet;
-    class?: string;
-    onclick?: () => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type GroupProps = typeof __propDef.props;
+export type GroupEvents = typeof __propDef.events;
+export type GroupSlots = typeof __propDef.slots;
+export default class Group extends SvelteComponentTyped<GroupProps, GroupEvents, GroupSlots> {
 }
-declare const Group: import("svelte").Component<Props, {}, "expanded">;
-type Group = ReturnType<typeof Group>;
-export default Group;
+export {};

package/dist/ui/NavTree/Item.svelte.d.ts

@@ -1,33 +1,14 @@
-import type { Snippet } from 'svelte';
-/**
- * @cssvar {shorthand} --p - Padding
- * @cssvar {shorthand} --m - Margin
- * @cssvar {length} --r - Border radius
- * @cssvar {shorthand} --b - Border
- * @cssvar {color} --bg - Background color
- * @cssvar {color} --bg-active - Background when active
- * @cssvar {color} --bg-active-hover - Background when active and hovered
- * @cssvar {color} --bg-hover - Background on hover
- * @cssvar {color} --expander-color - Expander icon color
- * @cssvar {color} --expander-color-active - Expander icon color when active
- * @cssvar {color} --expander-color-hover - Expander icon color on hover
- * @cssvar {length} --expander-size - Expander icon size
- * @cssvar {color} --font-color - Text color
- * @cssvar {color} --font-color-active - Text color when active
- * @cssvar {color} --font-color-hover - Text color on hover
- * @cssvar {string} --font-weight - Font weight
- */
-interface Props {
-    label: string;
-    href?: string;
-    active?: boolean;
-    left?: Snippet;
-    right?: Snippet;
-    expanded?: boolean;
-    children?: Snippet;
-    class?: string;
-    onclick?: () => void;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ItemProps = typeof __propDef.props;
+export type ItemEvents = typeof __propDef.events;
+export type ItemSlots = typeof __propDef.slots;
+export default class Item extends SvelteComponentTyped<ItemProps, ItemEvents, ItemSlots> {
 }
-declare const Item: import("svelte").Component<Props, {}, "expanded">;
-type Item = ReturnType<typeof Item>;
-export default Item;
+export {};

package/dist/ui/NavTree/NavTree.svelte.d.ts

@@ -1,8 +1,14 @@
-import type { Snippet } from 'svelte';
-interface Props {
-    children?: Snippet;
-    class?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type NavTreeProps = typeof __propDef.props;
+export type NavTreeEvents = typeof __propDef.events;
+export type NavTreeSlots = typeof __propDef.slots;
+export default class NavTree extends SvelteComponentTyped<NavTreeProps, NavTreeEvents, NavTreeSlots> {
 }
-declare const NavTree: import("svelte").Component<Props, {}, "">;
-type NavTree = ReturnType<typeof NavTree>;
-export default NavTree;
+export {};

package/dist/ui/NavTree/index.d.ts

@@ -0,0 +1,9 @@
+import Root from './NavTree.svelte';
+import Item from './Item.svelte';
+import Group from './Group.svelte';
+declare const NavTree: typeof Root & {
+    Item: typeof Item;
+    Group: typeof Group;
+};
+export { NavTree, Item, Group };
+export default NavTree;

package/dist/ui/Stack/Stack.svelte.d.ts

@@ -1,19 +1,14 @@
-import type { Snippet } from 'svelte';
-/**
- * @cssvar {string} --direction - Flex direction (row | column)
- * @cssvar {length} --gap - Gap between items
- * @cssvar {string} --align - Align items
- * @cssvar {string} --justify - Justify content
- * @cssvar {string} --wrap - Flex wrap
- * @cssvar {shorthand} --p - Padding
- * @cssvar {color} --bg - Background color
- * @cssvar {length} --r - Border radius
- * @cssvar {shorthand} --b - Border
- */
-interface Props {
-    children: Snippet;
-    class?: string;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type StackProps = typeof __propDef.props;
+export type StackEvents = typeof __propDef.events;
+export type StackSlots = typeof __propDef.slots;
+export default class Stack extends SvelteComponentTyped<StackProps, StackEvents, StackSlots> {
 }
-declare const Stack: import("svelte").Component<Props, {}, "">;
-type Stack = ReturnType<typeof Stack>;
-export default Stack;
+export {};

package/dist/vite.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { loadConfig, resolveConfig } from './server/config.js';
+import { loadRawConfig, resolveAndFinalize } from './server/config.js';
 import { discoverDocFiles, getSdocKind } from './server/discovery.js';
 import { parseDocSource } from './server/meta-parser.js';
 import { parseComponent } from './server/prop-parser.js';
@@ -22,12 +22,9 @@ export function sdocsPlugin(userConfig) {
         name: 'sdocs',
         async configResolved(resolvedConfig) {
             root = resolvedConfig.root;
-            if (userConfig) {
-                config = resolveConfig(userConfig);
-            }
-            else {
-                config = await loadConfig(root);
-            }
+            const fileConfig = await loadRawConfig(root);
+            const merged = { ...fileConfig, ...userConfig };
+            config = resolveAndFinalize(merged, root);
         },
         configureServer(devServer) {
             server = devServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdocs",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "A lightweight documentation tool for Svelte 5 components",
   "type": "module",
   "license": "MIT",
@@ -29,9 +29,9 @@
     "bin"
   ],
   "peerDependencies": {
-    "@sveltejs/vite-plugin-svelte": "^5.0.0 || ^6.0.0 || ^7.0.0",
-    "svelte": "^5.0.0",
-    "vite": "^6.0.0 || ^7.0.0"
+    "@sveltejs/vite-plugin-svelte": "*",
+    "svelte": "*",
+    "vite": "*"
   },
   "devDependencies": {
     "@sveltejs/package": "^2.5.7",