@wirekyt/svelte 0.0.1 → 0.0.2

package/dist/components/tree-view/item-indicator.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewItemIndicatorBaseProps extends PolymorphicProps<"div">, RefAttribute {
+}
+export interface TreeViewItemIndicatorProps extends Assign<HTMLProps<"div">, TreeViewItemIndicatorBaseProps> {
+}
+declare const ItemIndicator: import("svelte").Component<TreeViewItemIndicatorProps, {}, "ref">;
+type ItemIndicator = ReturnType<typeof ItemIndicator>;
+export default ItemIndicator;

package/dist/components/tree-view/item-text.svelte

@@ -0,0 +1,26 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface TreeViewItemTextBaseProps extends PolymorphicProps<"span">, RefAttribute {}
+  export interface TreeViewItemTextProps extends Assign<
+    HTMLProps<"span">,
+    TreeViewItemTextBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { useTreeViewContext } from "./use-context";
+  import { useTreeViewNodePropsContext } from "./use-node-props-context";
+
+  let { ref = $bindable(null), ...props }: TreeViewItemTextProps = $props();
+
+  const treeView = useTreeViewContext();
+  const nodeProps = useTreeViewNodePropsContext();
+
+  const mergedProps = $derived(mergeProps(treeView().getItemTextProps(nodeProps()), props));
+</script>
+
+<Wire as="span" bind:ref {...mergedProps} />

package/dist/components/tree-view/item-text.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewItemTextBaseProps extends PolymorphicProps<"span">, RefAttribute {
+}
+export interface TreeViewItemTextProps extends Assign<HTMLProps<"span">, TreeViewItemTextBaseProps> {
+}
+declare const ItemText: import("svelte").Component<TreeViewItemTextProps, {}, "ref">;
+type ItemText = ReturnType<typeof ItemText>;
+export default ItemText;

package/dist/components/tree-view/item.svelte

@@ -0,0 +1,22 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface TreeViewItemBaseProps extends PolymorphicProps<"li">, RefAttribute {}
+  export interface TreeViewItemProps extends Assign<HTMLProps<"li">, TreeViewItemBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { useTreeViewContext } from "./use-context";
+  import { useTreeViewNodePropsContext } from "./use-node-props-context";
+
+  let { ref = $bindable(null), ...props }: TreeViewItemProps = $props();
+
+  const treeView = useTreeViewContext();
+  const nodeProps = useTreeViewNodePropsContext();
+  const mergedProps = $derived(mergeProps(treeView().getItemProps(nodeProps()), props));
+</script>
+
+<Wire as="li" bind:ref {...mergedProps} />

package/dist/components/tree-view/item.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewItemBaseProps extends PolymorphicProps<"li">, RefAttribute {
+}
+export interface TreeViewItemProps extends Assign<HTMLProps<"li">, TreeViewItemBaseProps> {
+}
+declare const Item: import("svelte").Component<TreeViewItemProps, {}, "ref">;
+type Item = ReturnType<typeof Item>;
+export default Item;

package/dist/components/tree-view/label.svelte

@@ -0,0 +1,20 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface TreeViewLabelBaseProps extends PolymorphicProps<"h3">, RefAttribute {}
+  export interface TreeViewLabelProps extends Assign<HTMLProps<"h3">, TreeViewLabelBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { useTreeViewContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: TreeViewLabelProps = $props();
+
+  const treeView = useTreeViewContext();
+  const mergedProps = $derived(mergeProps(treeView().getLabelProps(), props));
+</script>
+
+<Wire as="h3" bind:ref {...mergedProps} />

package/dist/components/tree-view/label.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewLabelBaseProps extends PolymorphicProps<"h3">, RefAttribute {
+}
+export interface TreeViewLabelProps extends Assign<HTMLProps<"h3">, TreeViewLabelBaseProps> {
+}
+declare const Label: import("svelte").Component<TreeViewLabelProps, {}, "ref">;
+type Label = ReturnType<typeof Label>;
+export default Label;

package/dist/components/tree-view/node-checkbox-indicator.svelte

@@ -0,0 +1,27 @@
+<script module lang="ts">
+  import type { Snippet } from "svelte";
+
+  export interface TreeViewNodeCheckboxIndicatorBaseProps {
+    children?: Snippet;
+    indeterminate?: Snippet;
+    fallback?: Snippet;
+  }
+  export interface TreeViewNodeCheckboxIndicatorProps extends TreeViewNodeCheckboxIndicatorBaseProps {}
+</script>
+
+<script lang="ts">
+  import { useTreeViewNodeContext } from "./use-node-context";
+
+  const { children, indeterminate, fallback }: TreeViewNodeCheckboxIndicatorProps = $props();
+
+  const nodeState = useTreeViewNodeContext();
+  const checkedState = $derived(nodeState().checked);
+</script>
+
+{#if checkedState === "indeterminate" && indeterminate}
+  {@render indeterminate()}
+{:else if checkedState === true && children}
+  {@render children()}
+{:else if fallback}
+  {@render fallback()}
+{/if}

package/dist/components/tree-view/node-checkbox-indicator.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Snippet } from "svelte";
+export interface TreeViewNodeCheckboxIndicatorBaseProps {
+    children?: Snippet;
+    indeterminate?: Snippet;
+    fallback?: Snippet;
+}
+export interface TreeViewNodeCheckboxIndicatorProps extends TreeViewNodeCheckboxIndicatorBaseProps {
+}
+declare const NodeCheckboxIndicator: import("svelte").Component<TreeViewNodeCheckboxIndicatorProps, {}, "">;
+type NodeCheckboxIndicator = ReturnType<typeof NodeCheckboxIndicator>;
+export default NodeCheckboxIndicator;

package/dist/components/tree-view/node-checkbox.svelte

@@ -0,0 +1,26 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface TreeViewNodeCheckboxBaseProps extends PolymorphicProps<"span">, RefAttribute {}
+  export interface TreeViewNodeCheckboxProps extends Assign<
+    HTMLProps<"span">,
+    TreeViewNodeCheckboxBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { useTreeViewContext } from "./use-context";
+  import { useTreeViewNodePropsContext } from "./use-node-props-context";
+
+  let { ref = $bindable(null), ...props }: TreeViewNodeCheckboxProps = $props();
+
+  const treeView = useTreeViewContext();
+  const nodeProps = useTreeViewNodePropsContext();
+
+  const mergedProps = $derived(mergeProps(treeView().getNodeCheckboxProps(nodeProps()), props));
+</script>
+
+<Wire as="span" bind:ref {...mergedProps} />

package/dist/components/tree-view/node-checkbox.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewNodeCheckboxBaseProps extends PolymorphicProps<"span">, RefAttribute {
+}
+export interface TreeViewNodeCheckboxProps extends Assign<HTMLProps<"span">, TreeViewNodeCheckboxBaseProps> {
+}
+declare const NodeCheckbox: import("svelte").Component<TreeViewNodeCheckboxProps, {}, "ref">;
+type NodeCheckbox = ReturnType<typeof NodeCheckbox>;
+export default NodeCheckbox;

package/dist/components/tree-view/node-context.svelte

@@ -0,0 +1,20 @@
+<script module lang="ts">
+  import type { TreeNode } from "@wirekyt/dom/collection";
+  import type { Snippet } from "svelte";
+
+  import type { UseTreeViewNodeContext } from "./use-node-context";
+
+  export interface TreeViewNodeContextProps {
+    render: Snippet<[UseTreeViewNodeContext]>;
+  }
+</script>
+
+<script lang="ts" generics="T extends TreeNode">
+  import { useTreeViewNodeContext } from "./use-node-context";
+
+  const { render }: TreeViewNodeContextProps = $props();
+
+  const nodeContext = useTreeViewNodeContext();
+</script>
+
+{@render render(nodeContext)}

package/dist/components/tree-view/node-context.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { TreeNode } from "@wirekyt/dom/collection";
+import type { Snippet } from "svelte";
+import type { UseTreeViewNodeContext } from "./use-node-context";
+export interface TreeViewNodeContextProps {
+    render: Snippet<[UseTreeViewNodeContext]>;
+}
+declare function $$render<T extends TreeNode>(): {
+    props: TreeViewNodeContextProps;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends TreeNode> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends TreeNode>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends TreeNode>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const NodeContext: $$IsomorphicComponent;
+type NodeContext<T extends TreeNode> = InstanceType<typeof NodeContext<T>>;
+export default NodeContext;

package/dist/components/tree-view/node-provider.svelte

@@ -0,0 +1,32 @@
+<script module lang="ts">
+  import type { Snippet } from "svelte";
+
+  import type { TreeNode } from "../collection";
+
+  export interface TreeViewNodeProviderBaseProps<T extends TreeNode> {
+    node: T;
+    indexPath: number[];
+  }
+  export interface TreeViewNodeProviderProps<
+    T extends TreeNode,
+  > extends TreeViewNodeProviderBaseProps<T> {
+    children?: Snippet;
+  }
+</script>
+
+<script lang="ts" generics="T extends TreeNode">
+  import { useTreeViewContext } from "./use-context";
+  import { TreeViewNodeProvider } from "./use-node-context";
+  import { TreeViewNodePropsProvider } from "./use-node-props-context";
+
+  let { node, indexPath, children }: TreeViewNodeProviderProps<T> = $props();
+
+  const treeView = useTreeViewContext();
+  const nodeProps = $derived({ node, indexPath });
+  const nodeState = $derived(treeView().getNodeState(nodeProps));
+
+  TreeViewNodeProvider(() => nodeState);
+  TreeViewNodePropsProvider(() => nodeProps);
+</script>
+
+{@render children?.()}

package/dist/components/tree-view/node-provider.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { Snippet } from "svelte";
+import type { TreeNode } from "../collection";
+export interface TreeViewNodeProviderBaseProps<T extends TreeNode> {
+    node: T;
+    indexPath: number[];
+}
+export interface TreeViewNodeProviderProps<T extends TreeNode> extends TreeViewNodeProviderBaseProps<T> {
+    children?: Snippet;
+}
+declare function $$render<T extends TreeNode>(): {
+    props: TreeViewNodeProviderProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends TreeNode> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends TreeNode>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends TreeNode>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const NodeProvider: $$IsomorphicComponent;
+type NodeProvider<T extends TreeNode> = InstanceType<typeof NodeProvider<T>>;
+export default NodeProvider;

package/dist/components/tree-view/node-rename-input.svelte

@@ -0,0 +1,26 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface TreeViewNodeRenameInputBaseProps
+    extends PolymorphicProps<"input">, RefAttribute {}
+  export interface TreeViewNodeRenameInputProps extends Assign<
+    HTMLProps<"input">,
+    TreeViewNodeRenameInputBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { useTreeViewContext } from "./use-context";
+  import { useTreeViewNodePropsContext } from "./use-node-props-context";
+
+  let { ref = $bindable(null), ...props }: TreeViewNodeRenameInputProps = $props();
+
+  const treeView = useTreeViewContext();
+  const nodeProps = useTreeViewNodePropsContext();
+  const mergedProps = $derived(mergeProps(treeView().getNodeRenameInputProps(nodeProps()), props));
+</script>
+
+<Wire as="input" bind:ref {...mergedProps} />

package/dist/components/tree-view/node-rename-input.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+export interface TreeViewNodeRenameInputBaseProps extends PolymorphicProps<"input">, RefAttribute {
+}
+export interface TreeViewNodeRenameInputProps extends Assign<HTMLProps<"input">, TreeViewNodeRenameInputBaseProps> {
+}
+declare const NodeRenameInput: import("svelte").Component<TreeViewNodeRenameInputProps, {}, "ref">;
+type NodeRenameInput = ReturnType<typeof NodeRenameInput>;
+export default NodeRenameInput;

package/dist/components/tree-view/root-provider.svelte

@@ -0,0 +1,42 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+  import type { Snippet } from "svelte";
+
+  import type { TreeNode } from "../collection";
+  import type { UseTreeViewReturn } from "./use.svelte";
+
+  export interface TreeViewRootProviderBaseProps<T extends TreeNode>
+    extends RenderStrategyProps, PolymorphicProps<"div">, RefAttribute {
+    value: UseTreeViewReturn<T>;
+  }
+  export interface TreeViewRootProviderProps<T extends TreeNode> extends Assign<
+    HTMLProps<"div">,
+    TreeViewRootProviderBaseProps<T>
+  > {}
+
+  export type TreeViewRootProviderComponent<P = {}> = <T extends TreeNode>(
+    props: Assign<TreeViewRootProviderProps<T>, P>,
+  ) => Snippet;
+</script>
+
+<script lang="ts" generics="T extends TreeNode">
+  import { mergeProps } from "../../core";
+  import {
+    RenderStrategyPropsProvider,
+    splitRenderStrategyProps,
+    type RenderStrategyProps,
+  } from "../../utils";
+
+  import { Wire } from "../factory";
+  import { TreeViewProvider } from "./use-context";
+
+  let { ref = $bindable(null), value, ...props }: TreeViewRootProviderProps<T> = $props();
+
+  const [renderStrategyProps, treeViewProps] = $derived(splitRenderStrategyProps(props));
+  const mergedProps = $derived(mergeProps(value().getRootProps(), treeViewProps));
+
+  TreeViewProvider(() => value());
+  RenderStrategyPropsProvider(() => renderStrategyProps);
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/tree-view/root-provider.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+import type { Snippet } from "svelte";
+import type { TreeNode } from "../collection";
+import type { UseTreeViewReturn } from "./use.svelte";
+export interface TreeViewRootProviderBaseProps<T extends TreeNode> extends RenderStrategyProps, PolymorphicProps<"div">, RefAttribute {
+    value: UseTreeViewReturn<T>;
+}
+export interface TreeViewRootProviderProps<T extends TreeNode> extends Assign<HTMLProps<"div">, TreeViewRootProviderBaseProps<T>> {
+}
+export type TreeViewRootProviderComponent<P = {}> = <T extends TreeNode>(props: Assign<TreeViewRootProviderProps<T>, P>) => Snippet;
+import { type RenderStrategyProps } from "../../utils";
+declare function $$render<T extends TreeNode>(): {
+    props: TreeViewRootProviderProps<T>;
+    exports: {};
+    bindings: "ref";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends TreeNode> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends TreeNode>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends TreeNode>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const RootProvider: $$IsomorphicComponent;
+type RootProvider<T extends TreeNode> = InstanceType<typeof RootProvider<T>>;
+export default RootProvider;

package/dist/components/tree-view/root.svelte

@@ -0,0 +1,85 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+  import type { Snippet } from "svelte";
+
+  import type { TreeNode } from "../collection";
+  import type { UseTreeViewProps } from "./use.svelte";
+
+  export interface TreeViewRootBaseProps<T extends TreeNode>
+    extends UseTreeViewProps<T>, RenderStrategyProps, PolymorphicProps<"div">, RefAttribute {}
+
+  export interface TreeViewRootProps<T extends TreeNode> extends Assign<
+    HTMLProps<"div">,
+    TreeViewRootBaseProps<T>
+  > {}
+
+  export type TreeViewRootComponentProps<T extends TreeNode = TreeNode, P = {}> = Assign<
+    TreeViewRootProps<T>,
+    P
+  >;
+
+  export type TreeViewRootComponent<P = {}> = <T extends TreeNode>(
+    props: TreeViewRootComponentProps<T, P>,
+  ) => Snippet;
+</script>
+
+<script lang="ts" generics="T extends TreeNode">
+  import { mergeProps } from "../../core";
+  import {
+    RenderStrategyPropsProvider,
+    splitRenderStrategyProps,
+    type RenderStrategyProps,
+  } from "../../utils";
+
+  import { Wire } from "../factory";
+  import { splitTreeViewProps } from "./split-props";
+  import { TreeViewProvider } from "./use-context";
+  import { useTreeView } from "./use.svelte";
+
+  let {
+    ref = $bindable(null),
+    expandedValue = $bindable<string[]>(),
+    selectedValue = $bindable<string[]>(),
+    focusedValue = $bindable<string>(),
+    checkedValue = $bindable<string[]>(),
+    ...props
+  }: TreeViewRootProps<T> = $props();
+
+  const [renderStrategyProps, treeViewProps] = $derived(splitRenderStrategyProps(props));
+  const [useTreeViewProps, localProps] = $derived(splitTreeViewProps(treeViewProps));
+
+  const id = $props.id();
+
+  const machineProps = $derived.by<UseTreeViewProps<T>>(() => ({
+    ...useTreeViewProps,
+    id: useTreeViewProps.id ?? id,
+    selectedValue,
+    expandedValue,
+    focusedValue,
+    checkedValue,
+    onExpandedChange: (details) => {
+      useTreeViewProps.onExpandedChange?.(details);
+      expandedValue = details.expandedValue;
+    },
+    onFocusChange: (details) => {
+      useTreeViewProps.onFocusChange?.(details);
+      focusedValue = details.focusedValue;
+    },
+    onSelectionChange: (details) => {
+      useTreeViewProps.onSelectionChange?.(details);
+      selectedValue = details.selectedValue;
+    },
+    onCheckedChange: (details) => {
+      useTreeViewProps.onCheckedChange?.(details);
+      checkedValue = details.checkedValue;
+    },
+  }));
+
+  const treeView = useTreeView(() => machineProps);
+  const mergedProps = $derived(mergeProps(treeView().getRootProps(), localProps));
+
+  TreeViewProvider(treeView);
+  RenderStrategyPropsProvider(() => renderStrategyProps);
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/tree-view/root.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+import type { Snippet } from "svelte";
+import type { TreeNode } from "../collection";
+import type { UseTreeViewProps } from "./use.svelte";
+export interface TreeViewRootBaseProps<T extends TreeNode> extends UseTreeViewProps<T>, RenderStrategyProps, PolymorphicProps<"div">, RefAttribute {
+}
+export interface TreeViewRootProps<T extends TreeNode> extends Assign<HTMLProps<"div">, TreeViewRootBaseProps<T>> {
+}
+export type TreeViewRootComponentProps<T extends TreeNode = TreeNode, P = {}> = Assign<TreeViewRootProps<T>, P>;
+export type TreeViewRootComponent<P = {}> = <T extends TreeNode>(props: TreeViewRootComponentProps<T, P>) => Snippet;
+import { type RenderStrategyProps } from "../../utils";
+declare function $$render<T extends TreeNode>(): {
+    props: TreeViewRootProps<T>;
+    exports: {};
+    bindings: "ref" | "focusedValue" | "expandedValue" | "selectedValue" | "checkedValue";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends TreeNode> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "ref" | "focusedValue" | "expandedValue" | "selectedValue" | "checkedValue";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends TreeNode>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends TreeNode>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Root: $$IsomorphicComponent;
+type Root<T extends TreeNode> = InstanceType<typeof Root<T>>;
+export default Root;

package/dist/components/tree-view/split-props.d.ts

@@ -0,0 +1,3 @@
+import type { TreeNode } from "../collection";
+import type { UseTreeViewProps } from "./use.svelte";
+export declare function splitTreeViewProps<T extends UseTreeViewProps<TreeNode>>(props: T): [UseTreeViewProps<any>, Omit<T, "id" | "ids" | "onFocusChange" | "translations" | "onCheckedChange" | "collection" | "selectionMode" | "scrollToIndexFn" | "focusedValue" | "defaultFocusedValue" | "expandedValue" | "defaultExpandedValue" | "selectedValue" | "defaultSelectedValue" | "defaultCheckedValue" | "checkedValue" | "onExpandedChange" | "onSelectionChange" | "canRename" | "onRenameStart" | "onBeforeRename" | "onRenameComplete" | "onLoadChildrenComplete" | "onLoadChildrenError" | "expandOnClick" | "typeahead" | "loadChildren">];

package/dist/components/tree-view/split-props.js

@@ -0,0 +1,33 @@
+import { createSplitProps } from "../../utils";
+const splitFn = createSplitProps();
+export function splitTreeViewProps(props) {
+    return splitFn(props, [
+        "canRename",
+        "checkedValue",
+        "collection",
+        "defaultCheckedValue",
+        "defaultExpandedValue",
+        "defaultFocusedValue",
+        "defaultSelectedValue",
+        "expandedValue",
+        "expandOnClick",
+        "focusedValue",
+        "id",
+        "ids",
+        "loadChildren",
+        "onBeforeRename",
+        "onCheckedChange",
+        "onExpandedChange",
+        "onFocusChange",
+        "onLoadChildrenComplete",
+        "onLoadChildrenError",
+        "onRenameComplete",
+        "onRenameStart",
+        "onSelectionChange",
+        "selectedValue",
+        "selectionMode",
+        "translations",
+        "typeahead",
+        "scrollToIndexFn",
+    ]);
+}

package/dist/components/tree-view/tree-view.d.ts

@@ -0,0 +1,21 @@
+export type { CheckedChangeDetails, ExpandedChangeDetails, FocusChangeDetails, LoadChildrenCompleteDetails, LoadChildrenDetails, LoadChildrenErrorDetails, NodeProps, NodeState, RenameCompleteDetails, RenameStartDetails, SelectionChangeDetails, } from "@wirekyt/dom/machines/tree-view";
+export { default as Branch, type TreeViewBranchBaseProps as BranchBaseProps, type TreeViewBranchProps as BranchProps, } from "./branch.svelte";
+export { default as BranchContent, type TreeViewBranchContentBaseProps as BranchContentBaseProps, type TreeViewBranchContentProps as BranchContentProps, } from "./branch-content.svelte";
+export { default as BranchControl, type TreeViewBranchControlBaseProps as BranchControlBaseProps, type TreeViewBranchControlProps as BranchControlProps, } from "./branch-control.svelte";
+export { default as BranchIndentGuide, type TreeViewBranchIndentGuideBaseProps as BranchIndentGuideBaseProps, type TreeViewBranchIndentGuideProps as BranchIndentGuideProps, } from "./branch-indent-guide.svelte";
+export { default as BranchIndicator, type TreeViewBranchIndicatorBaseProps as BranchIndicatorBaseProps, type TreeViewBranchIndicatorProps as BranchIndicatorProps, } from "./branch-indicator.svelte";
+export { default as BranchText, type TreeViewBranchTextBaseProps as BranchTextBaseProps, type TreeViewBranchTextProps as BranchTextProps, } from "./branch-text.svelte";
+export { default as BranchTrigger, type TreeViewBranchTriggerBaseProps as BranchTriggerBaseProps, type TreeViewBranchTriggerProps as BranchTriggerProps, } from "./branch-trigger.svelte";
+export { default as Context, type TreeViewContextProps as ContextProps } from "./context.svelte";
+export { default as Item, type TreeViewItemBaseProps as ItemBaseProps, type TreeViewItemProps as ItemProps, } from "./item.svelte";
+export { default as ItemIndicator, type TreeViewItemIndicatorBaseProps as ItemIndicatorBaseProps, type TreeViewItemIndicatorProps as ItemIndicatorProps, } from "./item-indicator.svelte";
+export { default as ItemText, type TreeViewItemTextBaseProps as ItemTextBaseProps, type TreeViewItemTextProps as ItemTextProps, } from "./item-text.svelte";
+export { default as Label, type TreeViewLabelBaseProps as LabelBaseProps, type TreeViewLabelProps as LabelProps, } from "./label.svelte";
+export { default as NodeCheckbox, type TreeViewNodeCheckboxBaseProps as NodeCheckboxBaseProps, type TreeViewNodeCheckboxProps as NodeCheckboxProps, } from "./node-checkbox.svelte";
+export { default as NodeCheckboxIndicator, type TreeViewNodeCheckboxIndicatorBaseProps as NodeCheckboxIndicatorBaseProps, type TreeViewNodeCheckboxIndicatorProps as NodeCheckboxIndicatorProps, } from "./node-checkbox-indicator.svelte";
+export { default as NodeRenameInput, type TreeViewNodeRenameInputBaseProps as NodeRenameInputBaseProps, type TreeViewNodeRenameInputProps as NodeRenameInputProps, } from "./node-rename-input.svelte";
+export { default as NodeContext, type TreeViewNodeContextProps as NodeContextProps, } from "./node-context.svelte";
+export { default as NodeProvider, type TreeViewNodeProviderBaseProps as NodeProviderBaseProps, type TreeViewNodeProviderProps as NodeProviderProps, } from "./node-provider.svelte";
+export { default as Root, type TreeViewRootBaseProps as RootBaseProps, type TreeViewRootComponent as RootComponent, type TreeViewRootComponentProps as RootComponentProps, type TreeViewRootProps as RootProps, } from "./root.svelte";
+export { default as RootProvider, type TreeViewRootProviderBaseProps as RootProviderBaseProps, type TreeViewRootProviderComponent as RootProviderComponent, type TreeViewRootProviderProps as RootProviderProps, } from "./root-provider.svelte";
+export { default as Tree, type TreeViewTreeBaseProps as TreeBaseProps, type TreeViewTreeProps as TreeProps, } from "./tree.svelte";

package/dist/components/tree-view/tree-view.js

@@ -0,0 +1,20 @@
+export { default as Branch, } from "./branch.svelte";
+export { default as BranchContent, } from "./branch-content.svelte";
+export { default as BranchControl, } from "./branch-control.svelte";
+export { default as BranchIndentGuide, } from "./branch-indent-guide.svelte";
+export { default as BranchIndicator, } from "./branch-indicator.svelte";
+export { default as BranchText, } from "./branch-text.svelte";
+export { default as BranchTrigger, } from "./branch-trigger.svelte";
+export { default as Context } from "./context.svelte";
+export { default as Item, } from "./item.svelte";
+export { default as ItemIndicator, } from "./item-indicator.svelte";
+export { default as ItemText, } from "./item-text.svelte";
+export { default as Label, } from "./label.svelte";
+export { default as NodeCheckbox, } from "./node-checkbox.svelte";
+export { default as NodeCheckboxIndicator, } from "./node-checkbox-indicator.svelte";
+export { default as NodeRenameInput, } from "./node-rename-input.svelte";
+export { default as NodeContext, } from "./node-context.svelte";
+export { default as NodeProvider, } from "./node-provider.svelte";
+export { default as Root, } from "./root.svelte";
+export { default as RootProvider, } from "./root-provider.svelte";
+export { default as Tree, } from "./tree.svelte";