@sprawlify/svelte 0.0.43 → 0.0.44

package/dist/components/fieldset/fieldset-legend.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+
+  export interface FieldsetLegendBaseProps extends PolymorphicProps<'legend'>, RefAttribute {}
+  export interface FieldsetLegendProps extends Assign<HTMLProps<'legend'>, FieldsetLegendBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { useFieldsetContext } from './use-fieldset-context'
+
+  let { ref = $bindable(null), ...props }: FieldsetLegendProps = $props()
+  const fieldset = useFieldsetContext()
+  const mergedProps = $derived(mergeProps(fieldset?.().getLegendProps(), props))
+</script>
+
+<Sprawlify as="legend" bind:ref {...mergedProps} />

package/dist/components/fieldset/fieldset-legend.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+export interface FieldsetLegendBaseProps extends PolymorphicProps<'legend'>, RefAttribute {
+}
+export interface FieldsetLegendProps extends Assign<HTMLProps<'legend'>, FieldsetLegendBaseProps> {
+}
+declare const FieldsetLegend: import("svelte").Component<FieldsetLegendProps, {}, "ref">;
+type FieldsetLegend = ReturnType<typeof FieldsetLegend>;
+export default FieldsetLegend;

package/dist/components/fieldset/fieldset-root-provider.svelte

@@ -0,0 +1,23 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import type { UseFieldsetReturn } from './use-fieldset.svelte'
+
+  export interface FieldsetRootProviderBaseProps extends PolymorphicProps<'fieldset'>, RefAttribute {
+    value: UseFieldsetReturn
+  }
+  export interface FieldsetRootProviderProps extends Assign<HTMLProps<'fieldset'>, FieldsetRootProviderBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { FieldsetProvider } from './use-fieldset-context'
+
+  let { ref = $bindable(null), ...props }: FieldsetRootProviderProps = $props()
+
+  const mergedProps = $derived(mergeProps(props.value().getRootProps(), props))
+
+  FieldsetProvider(props.value)
+</script>
+
+<Sprawlify as="fieldset" bind:ref {...mergedProps} />

package/dist/components/fieldset/fieldset-root-provider.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import type { UseFieldsetReturn } from './use-fieldset.svelte';
+export interface FieldsetRootProviderBaseProps extends PolymorphicProps<'fieldset'>, RefAttribute {
+    value: UseFieldsetReturn;
+}
+export interface FieldsetRootProviderProps extends Assign<HTMLProps<'fieldset'>, FieldsetRootProviderBaseProps> {
+}
+declare const FieldsetRootProvider: import("svelte").Component<FieldsetRootProviderProps, {}, "ref">;
+type FieldsetRootProvider = ReturnType<typeof FieldsetRootProvider>;
+export default FieldsetRootProvider;

package/dist/components/fieldset/fieldset-root.svelte

@@ -0,0 +1,41 @@
+<script module lang="ts">
+  import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import type { UseFieldsetProps } from './use-fieldset.svelte'
+
+  export interface FieldsetRootBaseProps extends UseFieldsetProps, PolymorphicProps<'fieldset'>, RefAttribute {}
+  export interface FieldsetRootProps extends Assign<HTMLProps<'fieldset'>, FieldsetRootBaseProps> {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { createSplitProps } from '../../utils/create-split-props'
+  import { Sprawlify } from '../factory'
+  import { FieldsetProvider } from './use-fieldset-context'
+  import { useFieldset } from './use-fieldset.svelte'
+
+  let { ref = $bindable(null), ...props }: FieldsetRootProps = $props()
+
+  const [useFieldsetProps, localProps] = $derived(
+    createSplitProps<UseFieldsetProps>()(props, ['id', 'disabled', 'invalid']),
+  )
+
+  const providedId = $props.id()
+
+  const machineProps = $derived.by<UseFieldsetProps>(() => {
+    return {
+      ...useFieldsetProps,
+      id: useFieldsetProps.id ?? providedId,
+    }
+  })
+
+  const fieldset = useFieldset(() => machineProps)
+  const mergedProps = $derived(mergeProps(fieldset().getRootProps(), localProps))
+
+  FieldsetProvider(fieldset)
+
+  function setNode(node: HTMLFieldSetElement | null) {
+    fieldset().setRootRef(node)
+  }
+</script>
+
+<Sprawlify as="fieldset" bind:ref {...mergedProps} {@attach setNode} />

package/dist/components/fieldset/fieldset-root.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Assign, HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import type { UseFieldsetProps } from './use-fieldset.svelte';
+export interface FieldsetRootBaseProps extends UseFieldsetProps, PolymorphicProps<'fieldset'>, RefAttribute {
+}
+export interface FieldsetRootProps extends Assign<HTMLProps<'fieldset'>, FieldsetRootBaseProps> {
+}
+declare const FieldsetRoot: import("svelte").Component<FieldsetRootProps, {}, "ref">;
+type FieldsetRoot = ReturnType<typeof FieldsetRoot>;
+export default FieldsetRoot;

package/dist/components/fieldset/fieldset.d.ts

@@ -0,0 +1,6 @@
+export { default as Root, type FieldsetRootProps } from './fieldset-root.svelte';
+export { default as RootProvider, type FieldsetRootProviderProps } from './fieldset-root-provider.svelte';
+export { default as Context, type FieldsetContextProps } from './fieldset-context.svelte';
+export { default as Legend, type FieldsetLegendProps } from './fieldset-legend.svelte';
+export { default as HelperText, type FieldsetHelperTextProps } from './fieldset-helper-text.svelte';
+export { default as ErrorText, type FieldsetErrorTextProps } from './fieldset-error-text.svelte';

package/dist/components/fieldset/fieldset.js

@@ -0,0 +1,6 @@
+export { default as Root } from './fieldset-root.svelte';
+export { default as RootProvider } from './fieldset-root-provider.svelte';
+export { default as Context } from './fieldset-context.svelte';
+export { default as Legend } from './fieldset-legend.svelte';
+export { default as HelperText } from './fieldset-helper-text.svelte';
+export { default as ErrorText } from './fieldset-error-text.svelte';

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

@@ -0,0 +1,10 @@
+export { default as FieldsetContext, type FieldsetContextProps } from './fieldset-context.svelte';
+export { default as FieldsetErrorText, type FieldsetErrorTextBaseProps, type FieldsetErrorTextProps, } from './fieldset-error-text.svelte';
+export { default as FieldsetHelperText, type FieldsetHelperTextBaseProps, type FieldsetHelperTextProps, } from './fieldset-helper-text.svelte';
+export { default as FieldsetLegend, type FieldsetLegendBaseProps, type FieldsetLegendProps, } from './fieldset-legend.svelte';
+export { default as FieldsetRootProvider, type FieldsetRootProviderBaseProps, type FieldsetRootProviderProps, } from './fieldset-root-provider.svelte';
+export { default as FieldsetRoot, type FieldsetRootBaseProps, type FieldsetRootProps } from './fieldset-root.svelte';
+export { fieldsetAnatomy } from './fieldset-anatomy';
+export { useFieldsetContext, type UseFieldsetContext } from './use-fieldset-context';
+export { useFieldset, type UseFieldsetProps, type UseFieldsetReturn } from './use-fieldset.svelte';
+export * as Fieldset from './fieldset';

package/dist/components/fieldset/index.js

@@ -0,0 +1,10 @@
+export { default as FieldsetContext } from './fieldset-context.svelte';
+export { default as FieldsetErrorText, } from './fieldset-error-text.svelte';
+export { default as FieldsetHelperText, } from './fieldset-helper-text.svelte';
+export { default as FieldsetLegend, } from './fieldset-legend.svelte';
+export { default as FieldsetRootProvider, } from './fieldset-root-provider.svelte';
+export { default as FieldsetRoot } from './fieldset-root.svelte';
+export { fieldsetAnatomy } from './fieldset-anatomy';
+export { useFieldsetContext } from './use-fieldset-context';
+export { useFieldset } from './use-fieldset.svelte';
+export * as Fieldset from './fieldset';

package/dist/components/fieldset/use-fieldset-context.d.ts

@@ -0,0 +1,4 @@
+import type { UseFieldsetReturn } from './use-fieldset.svelte';
+export interface UseFieldsetContext extends UseFieldsetReturn {
+}
+export declare const FieldsetProvider: (opts: UseFieldsetContext) => void, useFieldsetContext: (fallback?: UseFieldsetContext | undefined) => UseFieldsetContext;

package/dist/components/fieldset/use-fieldset-context.js

@@ -0,0 +1,5 @@
+import { createContext } from '../../utils/create-context';
+export const [FieldsetProvider, useFieldsetContext] = createContext({
+    name: 'FieldsetContext',
+    strict: false,
+});

package/dist/components/fieldset/use-fieldset.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLProps } from '../../types';
+import { type MaybeFunction } from '@sprawlify/primitives/utils';
+export interface UseFieldsetProps {
+    id?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+}
+export type UseFieldsetReturn = ReturnType<typeof useFieldset>;
+export declare const useFieldset: (inProps?: MaybeFunction<UseFieldsetProps>) => () => {
+    setRootRef: (el: Element | null) => void;
+    ids: {
+        legend: string;
+        errorText: string;
+        helperText: string;
+    };
+    disabled: boolean;
+    invalid: boolean;
+    getRootProps: () => HTMLProps<"fieldset">;
+    getLegendProps: () => HTMLProps<"legend">;
+    getHelperTextProps: () => HTMLProps<"span">;
+    getErrorTextProps: () => HTMLProps<"span">;
+};

package/dist/components/fieldset/use-fieldset.svelte.js

@@ -0,0 +1,88 @@
+import { useEnvironmentContext } from '../../providers';
+import { runIfFn } from '../../utils/run-if-fn';
+import { dataAttr } from '@sprawlify/primitives/dom-query';
+import { ensureProps } from '@sprawlify/primitives/utils';
+import { onMount } from 'svelte';
+import { parts } from './fieldset-anatomy';
+export const useFieldset = (inProps = {}) => {
+    const props = $derived.by(() => {
+        const resolvedProps = runIfFn(inProps);
+        ensureProps(resolvedProps, ['id']);
+        return resolvedProps;
+    });
+    const id = $derived(props.id);
+    const disabled = $derived(props.disabled ?? false);
+    const invalid = $derived(props.invalid ?? false);
+    const env = useEnvironmentContext();
+    let hasErrorText = $state(false);
+    let hasHelperText = $state(false);
+    let rootRef = $state(null);
+    const setRootRef = (el) => {
+        rootRef = el;
+    };
+    const legendId = $derived(`fieldset::${id}::legend`);
+    const errorTextId = $derived(`fieldset::${id}::error-text`);
+    const helperTextId = $derived(`fieldset::${id}::helper-text`);
+    const checkTextElements = () => {
+        if (!rootRef)
+            return;
+        const docOrShadowRoot = env().getRootNode();
+        hasErrorText = !!docOrShadowRoot.getElementById(errorTextId);
+        hasHelperText = !!docOrShadowRoot.getElementById(helperTextId);
+    };
+    onMount(() => {
+        checkTextElements();
+        if (rootRef) {
+            const win = env().getWindow();
+            const observer = new win.MutationObserver(checkTextElements);
+            observer.observe(rootRef, { childList: true, subtree: true });
+            return () => observer.disconnect();
+        }
+    });
+    const labelIds = $derived(() => {
+        const ids = [];
+        if (hasErrorText && invalid)
+            ids.push(errorTextId);
+        if (hasHelperText)
+            ids.push(helperTextId);
+        return ids.join(' ') || undefined;
+    });
+    const getRootProps = () => ({
+        ...parts.root.attrs,
+        disabled,
+        'data-disabled': dataAttr(disabled),
+        'data-invalid': dataAttr(invalid),
+        'aria-labelledby': legendId,
+        'aria-describedby': labelIds(),
+    });
+    const getLegendProps = () => ({
+        id: legendId,
+        ...parts.legend.attrs,
+        'data-disabled': dataAttr(disabled),
+        'data-invalid': dataAttr(invalid),
+    });
+    const getHelperTextProps = () => ({
+        id: helperTextId,
+        ...parts.helperText.attrs,
+    });
+    const getErrorTextProps = () => ({
+        id: errorTextId,
+        ...parts.errorText.attrs,
+        'aria-live': 'polite',
+    });
+    const api = $derived({
+        setRootRef,
+        ids: {
+            legend: legendId,
+            errorText: errorTextId,
+            helperText: helperTextId,
+        },
+        disabled,
+        invalid,
+        getRootProps,
+        getLegendProps,
+        getHelperTextProps,
+        getErrorTextProps,
+    });
+    return () => api;
+};

package/dist/components/highlight/highlight.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+  import { createSplitProps } from '../../utils/create-split-props'
+  import type { HTMLProps, Assign } from '../../types'
+  import { useHighlight, type UseHighlightProps } from './use-highlight.svelte'
+
+  export interface HighlightBaseProps extends UseHighlightProps {}
+  export interface HighlightProps extends Assign<HTMLProps<'mark'>, HighlightBaseProps> {}
+
+  const props: HighlightProps = $props()
+
+  const [highlightProps, localProps] = $derived(
+    createSplitProps<HighlightBaseProps>()(props, ['query', 'text', 'ignoreCase', 'matchAll', 'exactMatch']),
+  )
+
+  if (typeof props.text !== 'string') {
+    throw new Error('[ark-ui/highlight] text must be a string')
+  }
+
+  const chunks = useHighlight(() => highlightProps)
+</script>
+
+{#each chunks() as { text, match }, i}
+  {#if match}
+    <mark {...localProps}>{text}</mark>
+  {:else}
+    {text}
+  {/if}
+{/each}

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

@@ -0,0 +1,9 @@
+import type { HTMLProps, Assign } from '../../types';
+import { type UseHighlightProps } from './use-highlight.svelte';
+export interface HighlightBaseProps extends UseHighlightProps {
+}
+export interface HighlightProps extends Assign<HTMLProps<'mark'>, HighlightBaseProps> {
+}
+declare const Highlight: import("svelte").Component<HighlightProps, {}, "">;
+type Highlight = ReturnType<typeof Highlight>;
+export default Highlight;

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

@@ -0,0 +1,3 @@
+export { default as Highlight } from './highlight.svelte';
+export type { HighlightProps } from './highlight.svelte';
+export { useHighlight, type HighlightChunk, type UseHighlightProps } from './use-highlight.svelte';

package/dist/components/highlight/index.js

@@ -0,0 +1,2 @@
+export { default as Highlight } from './highlight.svelte';
+export { useHighlight } from './use-highlight.svelte';

package/dist/components/highlight/use-highlight.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor } from '../../types';
+import { type HighlightChunk, type HighlightWordProps } from '@sprawlify/primitives/highlight-word';
+import type { MaybeFunction } from '@sprawlify/primitives/utils';
+export interface UseHighlightProps extends HighlightWordProps {
+}
+export interface UseHighlightReturn extends Accessor<HighlightChunk[]> {
+}
+export declare const useHighlight: (props: MaybeFunction<UseHighlightProps>) => UseHighlightReturn;
+export type { HighlightChunk };

package/dist/components/highlight/use-highlight.svelte.js

@@ -0,0 +1,9 @@
+import { runIfFn } from '../../utils/run-if-fn';
+import { highlightWord } from '@sprawlify/primitives/highlight-word';
+export const useHighlight = (props) => {
+    const chunks = $derived.by(() => {
+        const resolvedProps = runIfFn(props);
+        return highlightWord(resolvedProps);
+    });
+    return () => chunks;
+};

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

@@ -0,0 +1,2 @@
+export { default as Portal } from './portal.svelte';
+export type { PortalProps } from './portal.svelte';

package/dist/components/portal/index.js

@@ -0,0 +1 @@
+export { default as Portal } from './portal.svelte';

package/dist/components/portal/portal.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+  import { type Snippet, getAllContexts, mount, tick, unmount } from 'svelte'
+
+  export interface PortalProps {
+    disabled?: boolean
+    container?: HTMLElement
+    children: Snippet
+  }
+
+  let { children, container = globalThis.document?.body, disabled = false }: PortalProps = $props()
+
+  const context = getAllContexts()
+
+  let instance: any = null
+  $effect(() => {
+    const cleanup = () => {
+      if (instance) {
+        void unmount(instance)
+        instance = null
+      }
+    }
+
+    if (disabled) {
+      cleanup()
+      return
+    }
+
+    tick().then(() => {
+      instance = mount(children, { target: container, context })
+    })
+    return () => {
+      cleanup()
+    }
+  })
+</script>
+
+{#if disabled}
+  {@render children?.()}
+{/if}

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

@@ -0,0 +1,9 @@
+import { type Snippet } from 'svelte';
+export interface PortalProps {
+    disabled?: boolean;
+    container?: HTMLElement;
+    children: Snippet;
+}
+declare const Portal: import("svelte").Component<PortalProps, {}, "">;
+type Portal = ReturnType<typeof Portal>;
+export default Portal;

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

@@ -0,0 +1,4 @@
+export { default as Presence, type PresenceProps } from './presence.svelte';
+export { splitPresenceProps } from './split-presence-props.svelte';
+export { PresenceProvider, usePresenceContext, type UsePresenceContext } from './use-presence-context';
+export { usePresence, type UsePresenceProps, type UsePresenceReturn } from './use-presence.svelte';

package/dist/components/presence/index.js

@@ -0,0 +1,4 @@
+export { default as Presence } from './presence.svelte';
+export { splitPresenceProps } from './split-presence-props.svelte';
+export { PresenceProvider, usePresenceContext } from './use-presence-context';
+export { usePresence } from './use-presence.svelte';

package/dist/components/presence/presence.svelte

@@ -0,0 +1,28 @@
+<script module lang="ts">
+  import type { HTMLProps, PolymorphicProps, RefAttribute } from '../../types'
+  import { type UsePresenceProps, usePresence } from './use-presence.svelte'
+
+  export interface PresenceBaseProps extends UsePresenceProps, PolymorphicProps<'div'>, RefAttribute {}
+  export interface PresenceProps extends HTMLProps<'div'>, PresenceBaseProps {}
+</script>
+
+<script lang="ts">
+  import { mergeProps } from '../../core'
+  import { Sprawlify } from '../factory'
+  import { splitPresenceProps } from './split-presence-props.svelte'
+
+  let { ref = $bindable(null), ...props }: PresenceProps = $props()
+
+  const [presenceProps, localProps] = $derived(splitPresenceProps(props))
+  const presence = usePresence(() => presenceProps)
+
+  const mergedProps = $derived(mergeProps(presence().getPresenceProps(), localProps))
+
+  function setNode(node: Element | null) {
+    presence().setNode(node)
+  }
+</script>
+
+{#if !presence().unmounted}
+  <Sprawlify as="div" bind:ref data-scope="presence" data-part="root" {@attach setNode} {...mergedProps} />
+{/if}

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

@@ -0,0 +1,9 @@
+import type { HTMLProps, PolymorphicProps, RefAttribute } from '../../types';
+import { type UsePresenceProps } from './use-presence.svelte';
+export interface PresenceBaseProps extends UsePresenceProps, PolymorphicProps<'div'>, RefAttribute {
+}
+export interface PresenceProps extends HTMLProps<'div'>, PresenceBaseProps {
+}
+declare const Presence: import("svelte").Component<PresenceProps, {}, "ref">;
+type Presence = ReturnType<typeof Presence>;
+export default Presence;

package/dist/components/presence/split-presence-props.svelte.d.ts

@@ -0,0 +1,2 @@
+import type { UsePresenceProps } from './use-presence.svelte';
+export declare const splitPresenceProps: <T extends UsePresenceProps>(props: T) => [UsePresenceProps, Omit<T, "onExitComplete" | "lazyMount" | "unmountOnExit" | "present" | "immediate" | "skipAnimationOnMount">];

package/dist/components/presence/split-presence-props.svelte.js

@@ -0,0 +1,9 @@
+import { createSplitProps } from '../../utils/create-split-props';
+export const splitPresenceProps = (props) => createSplitProps()(props, [
+    'immediate',
+    'lazyMount',
+    'onExitComplete',
+    'present',
+    'skipAnimationOnMount',
+    'unmountOnExit',
+]);

package/dist/components/presence/use-presence-context.d.ts

@@ -0,0 +1,4 @@
+import type { UsePresenceReturn } from './use-presence.svelte';
+export interface UsePresenceContext extends UsePresenceReturn {
+}
+export declare const PresenceProvider: (opts: UsePresenceContext) => void, usePresenceContext: (fallback?: UsePresenceContext | undefined) => UsePresenceContext;

package/dist/components/presence/use-presence-context.js

@@ -0,0 +1,4 @@
+import { createContext } from '../../utils/create-context';
+export const [PresenceProvider, usePresenceContext] = createContext({
+    name: 'PresenceContext',
+});

package/dist/components/presence/use-presence.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { Optional } from '../../types';
+import { type RenderStrategyProps } from '../../utils/render-strategy';
+import * as presence from '@sprawlify/primitives/machines/presence';
+import { type MaybeFunction } from '@sprawlify/primitives/utils';
+export interface UsePresenceProps extends Optional<presence.Props, 'present'>, RenderStrategyProps {
+    skipAnimationOnMount?: boolean;
+}
+export interface UsePresenceReturn extends ReturnType<typeof usePresence> {
+}
+export declare const usePresence: (props: MaybeFunction<UsePresenceProps>) => () => {
+    getPresenceProps: () => {
+        'data-state': string | undefined;
+        hidden: boolean;
+    };
+    present: boolean;
+    setNode: (node: Element | null) => void;
+    unmounted: boolean | undefined;
+};

package/dist/components/presence/use-presence.svelte.js

@@ -0,0 +1,33 @@
+import { splitRenderStrategyProps } from '../../utils/render-strategy';
+import * as presence from '@sprawlify/primitives/machines/presence';
+import { normalizeProps, useMachine } from '../../core';
+import { runIfFn } from '@sprawlify/primitives/utils';
+export const usePresence = (props) => {
+    const resolvedProps = $derived(runIfFn(props));
+    const [renderStrategyProps, machineProps] = $derived(splitRenderStrategyProps(resolvedProps));
+    const service = useMachine(presence.machine, () => machineProps);
+    const api = $derived(presence.connect(service, normalizeProps));
+    let wasEverPresent = $state(false);
+    $effect(() => {
+        if (api.present) {
+            wasEverPresent = true;
+        }
+    });
+    const setNode = (node) => {
+        if (!node)
+            return;
+        service.send({ type: 'NODE.SET', node });
+    };
+    const unmounted = $derived((!api.present && !wasEverPresent && renderStrategyProps.lazyMount) ||
+        (renderStrategyProps.unmountOnExit && !api.present && wasEverPresent));
+    const result = $derived({
+        getPresenceProps: () => ({
+            'data-state': api.skip && resolvedProps.skipAnimationOnMount ? undefined : resolvedProps.present ? 'open' : 'closed',
+            hidden: !api.present,
+        }),
+        present: api.present,
+        setNode,
+        unmounted,
+    });
+    return () => result;
+};

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 '@sprawlify/primitives/machines/select';
+export { createListCollection, type CollectionItem, type ListCollection, useListCollection, type UseListCollectionProps, } from '../collection';
+export { default as SelectClearTrigger, type SelectClearTriggerBaseProps, type SelectClearTriggerProps, } from './select-clear-trigger.svelte';
+export { default as SelectContent, type SelectContentBaseProps, type SelectContentProps } from './select-content.svelte';
+export { default as SelectContext, type SelectContextProps } from './select-context.svelte';
+export { default as SelectControl, type SelectControlBaseProps, type SelectControlProps } from './select-control.svelte';
+export { default as SelectHiddenSelect, type SelectHiddenSelectBaseProps, type SelectHiddenSelectProps, } from './select-hidden-select.svelte';
+export { default as SelectIndicator, type SelectIndicatorBaseProps, type SelectIndicatorProps, } from './select-indicator.svelte';
+export { default as SelectItem, type SelectItemBaseProps, type SelectItemProps } from './select-item.svelte';
+export { default as SelectItemContext, type SelectItemContextProps } from './select-item-context.svelte';
+export { default as SelectItemGroup, type SelectItemGroupBaseProps, type SelectItemGroupProps, } from './select-item-group.svelte';
+export { default as SelectItemGroupLabel, type SelectItemGroupLabelBaseProps, type SelectItemGroupLabelProps, } from './select-item-group-label.svelte';
+export { default as SelectItemIndicator, type SelectItemIndicatorBaseProps, type SelectItemIndicatorProps, } from './select-item-indicator.svelte';
+export { default as SelectItemText, type SelectItemTextBaseProps, type SelectItemTextProps, } from './select-item-text.svelte';
+export { default as SelectLabel, type SelectLabelBaseProps, type SelectLabelProps } from './select-label.svelte';
+export { default as SelectList, type SelectListBaseProps, type SelectListProps } from './select-list.svelte';
+export { default as SelectPositioner, type SelectPositionerBaseProps, type SelectPositionerProps, } from './select-positioner.svelte';
+export { default as SelectRoot, type SelectRootBaseProps, type SelectRootProps, type SelectRootComponent, type SelectRootComponentProps, } from './select-root.svelte';
+export { default as SelectRootProvider, type SelectRootProviderBaseProps, type SelectRootProviderProps, type SelectRootProviderComponent, } from './select-root-provider.svelte';
+export { default as SelectTrigger, type SelectTriggerBaseProps, type SelectTriggerProps } from './select-trigger.svelte';
+export { default as SelectValueText, type SelectValueTextBaseProps, type SelectValueTextProps, } from './select-value-text.svelte';
+export { selectAnatomy } from './select-anatomy';
+export { useSelect, type UseSelectProps, type UseSelectReturn } from './use-select.svelte';
+export { useSelectContext, type UseSelectContext } from './use-select-context';
+export { useSelectItemContext, type UseSelectItemContext } from './use-select-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 './select-clear-trigger.svelte';
+export { default as SelectContent } from './select-content.svelte';
+export { default as SelectContext } from './select-context.svelte';
+export { default as SelectControl } from './select-control.svelte';
+export { default as SelectHiddenSelect, } from './select-hidden-select.svelte';
+export { default as SelectIndicator, } from './select-indicator.svelte';
+export { default as SelectItem } from './select-item.svelte';
+export { default as SelectItemContext } from './select-item-context.svelte';
+export { default as SelectItemGroup, } from './select-item-group.svelte';
+export { default as SelectItemGroupLabel, } from './select-item-group-label.svelte';
+export { default as SelectItemIndicator, } from './select-item-indicator.svelte';
+export { default as SelectItemText, } from './select-item-text.svelte';
+export { default as SelectLabel } from './select-label.svelte';
+export { default as SelectList } from './select-list.svelte';
+export { default as SelectPositioner, } from './select-positioner.svelte';
+export { default as SelectRoot, } from './select-root.svelte';
+export { default as SelectRootProvider, } from './select-root-provider.svelte';
+export { default as SelectTrigger } from './select-trigger.svelte';
+export { default as SelectValueText, } from './select-value-text.svelte';
+export { selectAnatomy } from './select-anatomy';
+export { useSelect } from './use-select.svelte';
+export { useSelectContext } from './use-select-context';
+export { useSelectItemContext } from './use-select-item-context';
+export * as Select from './select';

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

@@ -0,0 +1 @@
+export { anatomy as selectAnatomy } from '@sprawlify/primitives/machines/select';

package/dist/components/select/select-anatomy.js

@@ -0,0 +1 @@
+export { anatomy as selectAnatomy } from '@sprawlify/primitives/machines/select';

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

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