@wirekyt/svelte 0.0.1 → 0.0.2

package/dist/components/segment-group/item.svelte

@@ -0,0 +1,40 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+  import type { ItemProps } from "@wirekyt/dom/machines/radio-group";
+
+  export interface SegmentGroupItemBaseProps
+    extends ItemProps, PolymorphicProps<"label">, RefAttribute {}
+  export interface SegmentGroupItemProps extends Assign<
+    HTMLProps<"label">,
+    SegmentGroupItemBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+  import { createSplitProps } from "../../utils";
+
+  import { Wire } from "../factory";
+  import { parts } from "./anatomy";
+  import { useSegmentGroupContext } from "./use-context";
+  import { SegmentGroupItemProvider } from "./use-item-context";
+  import { SegmentGroupItemPropsProvider } from "./use-item-props-context";
+
+  let { ref = $bindable(null), ...props }: SegmentGroupItemProps = $props();
+
+  const [itemProps, localProps] = $derived(
+    createSplitProps<ItemProps>()(props, ["value", "disabled", "invalid"]),
+  );
+
+  const segmentGroup = useSegmentGroupContext();
+
+  const itemState = $derived(segmentGroup().getItemState(itemProps));
+  const mergedProps = $derived(
+    mergeProps(segmentGroup().getItemProps(itemProps), parts.item.attrs, localProps),
+  );
+
+  SegmentGroupItemProvider(() => itemState);
+  SegmentGroupItemPropsProvider(() => itemProps);
+</script>
+
+<Wire as="label" bind:ref {...mergedProps} />

package/dist/components/segment-group/item.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+import type { ItemProps } from "@wirekyt/dom/machines/radio-group";
+export interface SegmentGroupItemBaseProps extends ItemProps, PolymorphicProps<"label">, RefAttribute {
+}
+export interface SegmentGroupItemProps extends Assign<HTMLProps<"label">, SegmentGroupItemBaseProps> {
+}
+declare const Item: import("svelte").Component<SegmentGroupItemProps, {}, "ref">;
+type Item = ReturnType<typeof Item>;
+export default Item;

package/dist/components/segment-group/label.svelte

@@ -0,0 +1,26 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SegmentGroupLabelBaseProps extends PolymorphicProps<"span">, RefAttribute {}
+  export interface SegmentGroupLabelProps extends Assign<
+    HTMLProps<"span">,
+    SegmentGroupLabelBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { parts } from "./anatomy";
+  import { useSegmentGroupContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SegmentGroupLabelProps = $props();
+
+  const segmentGroup = useSegmentGroupContext();
+  const mergedProps = $derived(
+    mergeProps(segmentGroup().getLabelProps(), parts.label.attrs, props),
+  );
+</script>
+
+<Wire as="span" bind:ref {...mergedProps} />

package/dist/components/segment-group/label.svelte.d.ts

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

package/dist/components/segment-group/root-provider.svelte

@@ -0,0 +1,32 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  import type { UseSegmentGroupReturn } from "./use.svelte";
+
+  interface RootProviderProps {
+    value: UseSegmentGroupReturn;
+  }
+
+  export interface SegmentGroupRootProviderBaseProps
+    extends RootProviderProps, PolymorphicProps<"div">, RefAttribute {}
+  export interface SegmentGroupRootProviderProps extends Assign<
+    HTMLProps<"div">,
+    SegmentGroupRootProviderBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { parts } from "./anatomy";
+  import { SegmentGroupProvider } from "./use-context";
+
+  let { ref = $bindable(null), value, ...props }: SegmentGroupRootProviderProps = $props();
+
+  const mergedProps = $derived(mergeProps(value().getRootProps(), parts.root.attrs, props));
+
+  SegmentGroupProvider(() => value());
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/segment-group/root-provider.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+import type { UseSegmentGroupReturn } from "./use.svelte";
+interface RootProviderProps {
+    value: UseSegmentGroupReturn;
+}
+export interface SegmentGroupRootProviderBaseProps extends RootProviderProps, PolymorphicProps<"div">, RefAttribute {
+}
+export interface SegmentGroupRootProviderProps extends Assign<HTMLProps<"div">, SegmentGroupRootProviderBaseProps> {
+}
+declare const RootProvider: import("svelte").Component<SegmentGroupRootProviderProps, {}, "ref">;
+type RootProvider = ReturnType<typeof RootProvider>;
+export default RootProvider;

package/dist/components/segment-group/root.svelte

@@ -0,0 +1,51 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+  import type { ValueChangeDetails } from "@wirekyt/dom/machines/radio-group";
+
+  import type { UseSegmentGroupProps } from "./use.svelte";
+
+  export interface SegmentGroupRootEmits {
+    valueChange: ValueChangeDetails;
+  }
+
+  export interface SegmentGroupRootBaseProps
+    extends UseSegmentGroupProps, PolymorphicProps<"div">, RefAttribute {}
+  export interface SegmentGroupRootProps extends Assign<
+    HTMLProps<"div">,
+    SegmentGroupRootBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from "../../core";
+
+  import { Wire } from "../factory";
+  import { parts } from "./anatomy";
+  import { splitSegmentGroupProps } from "./split-props.svelte";
+  import { SegmentGroupProvider } from "./use-context";
+  import { useSegmentGroup } from "./use.svelte";
+
+  let { ref = $bindable(null), value = $bindable(), ...props }: SegmentGroupRootProps = $props();
+  const providedId = $props.id();
+
+  const [segmentGroupProps, localProps] = $derived(splitSegmentGroupProps(props));
+
+  const resolvedProps = $derived<UseSegmentGroupProps>({
+    ...segmentGroupProps,
+    id: segmentGroupProps.id ?? providedId,
+    value,
+    onValueChange(details) {
+      segmentGroupProps.onValueChange?.(details);
+      if (value !== undefined) value = details.value;
+    },
+  });
+
+  const segmentGroup = useSegmentGroup(() => resolvedProps);
+  const mergedProps = $derived(
+    mergeProps(segmentGroup().getRootProps(), parts.root.attrs, localProps),
+  );
+
+  SegmentGroupProvider(segmentGroup);
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/segment-group/root.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+import type { ValueChangeDetails } from "@wirekyt/dom/machines/radio-group";
+import type { UseSegmentGroupProps } from "./use.svelte";
+export interface SegmentGroupRootEmits {
+    valueChange: ValueChangeDetails;
+}
+export interface SegmentGroupRootBaseProps extends UseSegmentGroupProps, PolymorphicProps<"div">, RefAttribute {
+}
+export interface SegmentGroupRootProps extends Assign<HTMLProps<"div">, SegmentGroupRootBaseProps> {
+}
+declare const Root: import("svelte").Component<SegmentGroupRootProps, {}, "value" | "ref">;
+type Root = ReturnType<typeof Root>;
+export default Root;

package/dist/components/segment-group/segment-group.d.ts

@@ -0,0 +1,11 @@
+export type { ValueChangeDetails } from "@wirekyt/dom/machines/radio-group";
+export { default as Context, type SegmentGroupContextProps as ContextProps, } from "./context.svelte";
+export { default as Indicator, type SegmentGroupIndicatorProps as IndicatorProps, type SegmentGroupIndicatorBaseProps as IndicatorBaseProps, } from "./indicator.svelte";
+export { default as ItemContext, type SegmentGroupItemContextProps as ItemContextProps, } from "./item-context.svelte";
+export { default as ItemControl, type SegmentGroupItemControlProps as ItemControlProps, type SegmentGroupItemControlBaseProps as ItemControlBaseProps, } from "./item-control.svelte";
+export { default as ItemHiddenInput, type SegmentGroupItemHiddenInputProps as ItemHiddenInputProps, type SegmentGroupItemHiddenInputBaseProps as ItemHiddenInputBaseProps, } from "./item-hidden-input.svelte";
+export { default as ItemText, type SegmentGroupItemTextProps as ItemTextProps, type SegmentGroupItemTextBaseProps as ItemTextBaseProps, } from "./item-text.svelte";
+export { default as Item, type SegmentGroupItemProps as ItemProps, type SegmentGroupItemBaseProps as ItemBaseProps, } from "./item.svelte";
+export { default as Label, type SegmentGroupLabelProps as LabelProps, type SegmentGroupLabelBaseProps as LabelBaseProps, } from "./label.svelte";
+export { default as RootProvider, type SegmentGroupRootProviderProps as RootProviderProps, type SegmentGroupRootProviderBaseProps as RootProviderBaseProps, } from "./root-provider.svelte";
+export { default as Root, type SegmentGroupRootEmits as RootEmits, type SegmentGroupRootBaseProps as RootBaseProps, type SegmentGroupRootProps as RootProps, } from "./root.svelte";

package/dist/components/segment-group/segment-group.js

@@ -0,0 +1,10 @@
+export { default as Context, } from "./context.svelte";
+export { default as Indicator, } from "./indicator.svelte";
+export { default as ItemContext, } from "./item-context.svelte";
+export { default as ItemControl, } from "./item-control.svelte";
+export { default as ItemHiddenInput, } from "./item-hidden-input.svelte";
+export { default as ItemText, } from "./item-text.svelte";
+export { default as Item, } from "./item.svelte";
+export { default as Label, } from "./label.svelte";
+export { default as RootProvider, } from "./root-provider.svelte";
+export { default as Root, } from "./root.svelte";

package/dist/components/segment-group/split-props.svelte.d.ts

@@ -0,0 +1,2 @@
+import type { UseSegmentGroupProps } from "./use.svelte";
+export declare const splitSegmentGroupProps: <T extends UseSegmentGroupProps>(props: T) => [UseSegmentGroupProps, Omit<T, "value" | "defaultValue" | "disabled" | "id" | "ids" | "form" | "name" | "onValueChange" | "orientation" | "readOnly" | "invalid" | "required">];

package/dist/components/segment-group/split-props.svelte.js

@@ -0,0 +1,16 @@
+import { createSplitProps } from "../../utils";
+const splitFn = createSplitProps();
+export const splitSegmentGroupProps = (props) => splitFn(props, [
+    "defaultValue",
+    "disabled",
+    "form",
+    "id",
+    "ids",
+    "invalid",
+    "name",
+    "onValueChange",
+    "orientation",
+    "readOnly",
+    "required",
+    "value",
+]);

package/dist/components/segment-group/use-context.d.ts

@@ -0,0 +1,4 @@
+import type { UseSegmentGroupReturn } from "./use.svelte";
+export interface UseSegmentGroupContext extends UseSegmentGroupReturn {
+}
+export declare const SegmentGroupProvider: (opts: UseSegmentGroupContext) => void, useSegmentGroupContext: (fallback?: UseSegmentGroupContext | undefined) => UseSegmentGroupContext;

package/dist/components/segment-group/use-context.js

@@ -0,0 +1,6 @@
+import { createContext } from "../../utils";
+export const [SegmentGroupProvider, useSegmentGroupContext] = createContext({
+    name: "SegmentGroupContext",
+    hookName: "useSegmentGroupContext",
+    providerName: "<SegmentGroupProvider />",
+});

package/dist/components/segment-group/use-item-context.d.ts

@@ -0,0 +1,5 @@
+import type { Accessor } from "../../core";
+import type { ItemState } from "@wirekyt/dom/machines/radio-group";
+export interface UseSegmentGroupItemContext extends Accessor<ItemState> {
+}
+export declare const SegmentGroupItemProvider: (opts: UseSegmentGroupItemContext) => void, useSegmentGroupItemContext: (fallback?: UseSegmentGroupItemContext | undefined) => UseSegmentGroupItemContext;

package/dist/components/segment-group/use-item-context.js

@@ -0,0 +1,6 @@
+import { createContext } from "../../utils";
+export const [SegmentGroupItemProvider, useSegmentGroupItemContext] = createContext({
+    name: "SegmentGroupItemContext",
+    hookName: "useSegmentGroupItemContext",
+    providerName: "<SegmentGroupItemProvider />",
+});

package/dist/components/segment-group/use-item-props-context.d.ts

@@ -0,0 +1,5 @@
+import type { Accessor } from "../../core";
+import type { ItemProps } from "@wirekyt/dom/machines/radio-group";
+export interface UseSegmentGroupItemPropsContext extends Accessor<ItemProps> {
+}
+export declare const SegmentGroupItemPropsProvider: (opts: UseSegmentGroupItemPropsContext) => void, useSegmentGroupItemPropsContext: (fallback?: UseSegmentGroupItemPropsContext | undefined) => UseSegmentGroupItemPropsContext;

package/dist/components/segment-group/use-item-props-context.js

@@ -0,0 +1,6 @@
+import { createContext } from "../../utils";
+export const [SegmentGroupItemPropsProvider, useSegmentGroupItemPropsContext] = createContext({
+    name: "SegmentGroupItemPropsContext",
+    hookName: "useSegmentGroupItemPropsContext",
+    providerName: "<SegmentGroupItemPropsProvider />",
+});

package/dist/components/segment-group/use.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor, Optional } from "../../core";
+import { type PropTypes } from "../../core";
+import * as segmentGroup from "@wirekyt/dom/machines/radio-group";
+import { type MaybeFunction } from "@wirekyt/dom/utils";
+export interface UseSegmentGroupProps extends Optional<Omit<segmentGroup.Props, "dir" | "getRootNode">, "id"> {
+}
+export interface UseSegmentGroupReturn extends Accessor<segmentGroup.Api<PropTypes>> {
+}
+export declare const useSegmentGroup: (props: MaybeFunction<UseSegmentGroupProps>) => UseSegmentGroupReturn;

package/dist/components/segment-group/use.svelte.js

@@ -0,0 +1,19 @@
+import { normalizeProps, useMachine } from "../../core";
+import * as segmentGroup from "@wirekyt/dom/machines/radio-group";
+import { runIfFn } from "@wirekyt/dom/utils";
+import { useEnvironmentContext, useLocaleContext } from "../../providers";
+export const useSegmentGroup = (props) => {
+    const env = useEnvironmentContext();
+    const locale = useLocaleContext();
+    const resolvedProps = $derived.by(() => {
+        const localProps = runIfFn(props);
+        return {
+            dir: locale().dir,
+            getRootNode: env().getRootNode,
+            ...localProps,
+        };
+    });
+    const service = useMachine(segmentGroup.machine, () => resolvedProps);
+    const api = $derived(segmentGroup.connect(service, normalizeProps));
+    return () => api;
+};

package/dist/components/select/anatomy.d.ts

@@ -0,0 +1 @@
+export { anatomy as selectAnatomy } from "@wirekyt/dom/machines/select";

package/dist/components/select/anatomy.js

@@ -0,0 +1 @@
+export { anatomy as selectAnatomy } from "@wirekyt/dom/machines/select";

package/dist/components/select/clear-trigger.svelte

@@ -0,0 +1,22 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SelectClearTriggerBaseProps extends PolymorphicProps<"button">, RefAttribute {}
+  export interface SelectClearTriggerProps extends Assign<
+    HTMLProps<"button">,
+    SelectClearTriggerBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { Wire } from "../factory";
+  import { mergeProps } from "../../core";
+
+  import { useSelectContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SelectClearTriggerProps = $props();
+  const select = useSelectContext();
+  const mergedProps = $derived(mergeProps(select().getClearTriggerProps(), props));
+</script>
+
+<Wire as="button" bind:ref {...mergedProps} />

package/dist/components/select/clear-trigger.svelte.d.ts

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

package/dist/components/select/content.svelte

@@ -0,0 +1,29 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SelectContentBaseProps extends PolymorphicProps<"div">, RefAttribute {}
+  export interface SelectContentProps extends Assign<HTMLProps<"div">, SelectContentBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { Wire } from "../factory";
+  import { mergeProps } from "../../core";
+
+  import { usePresenceContext } from "../presence";
+  import { useSelectContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SelectContentProps = $props();
+  const select = useSelectContext();
+  const presence = usePresenceContext();
+  const mergedProps = $derived(
+    mergeProps(select().getContentProps(), presence().getPresenceProps(), props),
+  );
+
+  function setNode(node: Element | null) {
+    presence().setNode(node);
+  }
+</script>
+
+{#if !presence().unmounted}
+  <Wire as="div" bind:ref {...mergedProps} {@attach setNode} />
+{/if}

package/dist/components/select/content.svelte.d.ts

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

package/dist/components/select/context.svelte

@@ -0,0 +1,19 @@
+<script module lang="ts">
+  import type { Snippet } from "svelte";
+
+  import type { CollectionItem } from "../collection";
+  import type { UseSelectReturn } from "./use.svelte";
+
+  export interface SelectContextProps<T extends CollectionItem = CollectionItem> {
+    render: Snippet<[UseSelectReturn<T>]>;
+  }
+</script>
+
+<script lang="ts" generics="T extends CollectionItem = CollectionItem">
+  import { useSelectContext } from "./use-context";
+
+  const props: SelectContextProps<T> = $props();
+  const select = useSelectContext();
+</script>
+
+{@render props.render(select)}

package/dist/components/select/context.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { Snippet } from "svelte";
+import type { CollectionItem } from "../collection";
+import type { UseSelectReturn } from "./use.svelte";
+export interface SelectContextProps<T extends CollectionItem = CollectionItem> {
+    render: Snippet<[UseSelectReturn<T>]>;
+}
+declare function $$render<T extends CollectionItem = CollectionItem>(): {
+    props: SelectContextProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends CollectionItem = CollectionItem> {
+    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 CollectionItem = CollectionItem>(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 CollectionItem = CollectionItem>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Context: $$IsomorphicComponent;
+type Context<T extends CollectionItem = CollectionItem> = InstanceType<typeof Context<T>>;
+export default Context;

package/dist/components/select/control.svelte

@@ -0,0 +1,19 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SelectControlBaseProps extends PolymorphicProps<"div">, RefAttribute {}
+  export interface SelectControlProps extends Assign<HTMLProps<"div">, SelectControlBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { Wire } from "../factory";
+  import { mergeProps } from "../../core";
+
+  import { useSelectContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SelectControlProps = $props();
+  const select = useSelectContext();
+  const mergedProps = $derived(mergeProps(select().getControlProps(), props));
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/select/control.svelte.d.ts

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

package/dist/components/select/hidden-select.svelte

@@ -0,0 +1,34 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SelectHiddenSelectBaseProps extends PolymorphicProps<"select">, RefAttribute {}
+  export interface SelectHiddenSelectProps extends Assign<
+    HTMLProps<"select">,
+    SelectHiddenSelectBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { Wire } from "../factory";
+  import { mergeProps } from "../../core";
+
+  import { useSelectContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SelectHiddenSelectProps = $props();
+  const select = useSelectContext();
+  const mergedProps = $derived(mergeProps(select().getHiddenSelectProps(), props));
+</script>
+
+<Wire as="select" bind:ref {...mergedProps}>
+  {#if select().value.length === 0}
+    <option value=""></option>
+  {/if}
+  {#each select().collection.items as item}
+    <option
+      value={select().collection.getItemValue(item) ?? ""}
+      disabled={select().collection.getItemDisabled(item)}
+    >
+      {select().collection.stringifyItem(item)}
+    </option>
+  {/each}
+</Wire>

package/dist/components/select/hidden-select.svelte.d.ts

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

package/dist/components/select/index.d.ts

@@ -0,0 +1,26 @@
+export type { FocusOutsideEvent as SelectFocusOutsideEvent, HighlightChangeDetails as SelectHighlightChangeDetails, InteractOutsideEvent as SelectInteractOutsideEvent, OpenChangeDetails as SelectOpenChangeDetails, PointerDownOutsideEvent as SelectPointerDownOutsideEvent, ValueChangeDetails as SelectValueChangeDetails, } from "@wirekyt/dom/machines/select";
+export { createListCollection, type CollectionItem, type ListCollection, useListCollection, type UseListCollectionProps, } from "../collection";
+export { default as SelectClearTrigger, type SelectClearTriggerBaseProps, type SelectClearTriggerProps, } from "./clear-trigger.svelte";
+export { default as SelectContent, type SelectContentBaseProps, type SelectContentProps, } from "./content.svelte";
+export { default as SelectContext, type SelectContextProps } from "./context.svelte";
+export { default as SelectControl, type SelectControlBaseProps, type SelectControlProps, } from "./control.svelte";
+export { default as SelectHiddenSelect, type SelectHiddenSelectBaseProps, type SelectHiddenSelectProps, } from "./hidden-select.svelte";
+export { default as SelectIndicator, type SelectIndicatorBaseProps, type SelectIndicatorProps, } from "./indicator.svelte";
+export { default as SelectItem, type SelectItemBaseProps, type SelectItemProps, } from "./item.svelte";
+export { default as SelectItemContext, type SelectItemContextProps } from "./item-context.svelte";
+export { default as SelectItemGroup, type SelectItemGroupBaseProps, type SelectItemGroupProps, } from "./item-group.svelte";
+export { default as SelectItemGroupLabel, type SelectItemGroupLabelBaseProps, type SelectItemGroupLabelProps, } from "./item-group-label.svelte";
+export { default as SelectItemIndicator, type SelectItemIndicatorBaseProps, type SelectItemIndicatorProps, } from "./item-indicator.svelte";
+export { default as SelectItemText, type SelectItemTextBaseProps, type SelectItemTextProps, } from "./item-text.svelte";
+export { default as SelectLabel, type SelectLabelBaseProps, type SelectLabelProps, } from "./label.svelte";
+export { default as SelectList, type SelectListBaseProps, type SelectListProps, } from "./list.svelte";
+export { default as SelectPositioner, type SelectPositionerBaseProps, type SelectPositionerProps, } from "./positioner.svelte";
+export { default as SelectRoot, type SelectRootBaseProps, type SelectRootProps, type SelectRootComponent, type SelectRootComponentProps, } from "./root.svelte";
+export { default as SelectRootProvider, type SelectRootProviderBaseProps, type SelectRootProviderProps, type SelectRootProviderComponent, } from "./root-provider.svelte";
+export { default as SelectTrigger, type SelectTriggerBaseProps, type SelectTriggerProps, } from "./trigger.svelte";
+export { default as SelectValueText, type SelectValueTextBaseProps, type SelectValueTextProps, } from "./value-text.svelte";
+export { selectAnatomy } from "./anatomy";
+export { useSelect, type UseSelectProps, type UseSelectReturn } from "./use.svelte";
+export { useSelectContext, type UseSelectContext } from "./use-context";
+export { useSelectItemContext, type UseSelectItemContext } from "./use-item-context";
+export * as Select from "./select";

package/dist/components/select/index.js

@@ -0,0 +1,25 @@
+export { createListCollection, useListCollection, } from "../collection";
+export { default as SelectClearTrigger, } from "./clear-trigger.svelte";
+export { default as SelectContent, } from "./content.svelte";
+export { default as SelectContext } from "./context.svelte";
+export { default as SelectControl, } from "./control.svelte";
+export { default as SelectHiddenSelect, } from "./hidden-select.svelte";
+export { default as SelectIndicator, } from "./indicator.svelte";
+export { default as SelectItem, } from "./item.svelte";
+export { default as SelectItemContext } from "./item-context.svelte";
+export { default as SelectItemGroup, } from "./item-group.svelte";
+export { default as SelectItemGroupLabel, } from "./item-group-label.svelte";
+export { default as SelectItemIndicator, } from "./item-indicator.svelte";
+export { default as SelectItemText, } from "./item-text.svelte";
+export { default as SelectLabel, } from "./label.svelte";
+export { default as SelectList, } from "./list.svelte";
+export { default as SelectPositioner, } from "./positioner.svelte";
+export { default as SelectRoot, } from "./root.svelte";
+export { default as SelectRootProvider, } from "./root-provider.svelte";
+export { default as SelectTrigger, } from "./trigger.svelte";
+export { default as SelectValueText, } from "./value-text.svelte";
+export { selectAnatomy } from "./anatomy";
+export { useSelect } from "./use.svelte";
+export { useSelectContext } from "./use-context";
+export { useSelectItemContext } from "./use-item-context";
+export * as Select from "./select";

package/dist/components/select/indicator.svelte

@@ -0,0 +1,22 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from "../../core";
+
+  export interface SelectIndicatorBaseProps extends PolymorphicProps<"div">, RefAttribute {}
+  export interface SelectIndicatorProps extends Assign<
+    HTMLProps<"div">,
+    SelectIndicatorBaseProps
+  > {}
+</script>
+
+<script lang="ts">
+  import { Wire } from "../factory";
+  import { mergeProps } from "../../core";
+
+  import { useSelectContext } from "./use-context";
+
+  let { ref = $bindable(null), ...props }: SelectIndicatorProps = $props();
+  const select = useSelectContext();
+  const mergedProps = $derived(mergeProps(select().getIndicatorProps(), props));
+</script>
+
+<Wire as="div" bind:ref {...mergedProps} />

package/dist/components/select/indicator.svelte.d.ts

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