grassroot
Install

DocsAPI referenceHeadlessdrawer

drawer headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

Platform contract

@grassroot/ui-headless-core/drawer

Core connector and vanilla API

26 exports
View source packages/ui-headless/core/src/drawer/index.ts

activateDrawerManagers

function
DeclarationView source
activateDrawerManagersts
declare function activateDrawerManagers(service: DrawerService, scope: PartScope, doc: Document): () => void;
Name
Kind
Type
Requirement
service
parameter
DrawerService
required
scope
parameter
PartScope
required
doc
parameter
Document
required
return
return value
() => void
n/a
Name
service
Kind
parameter
Type
DrawerService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
doc
Kind
parameter
Type
Document
Requirement
required
Name
return
Kind
return value
Type
() => void
Requirement
n/a

connectDrawer

function
DeclarationView source
connectDrawerts
declare function connectDrawer(service: DrawerService, scope: PartScope, _options?: DrawerConnectOptions): DrawerApi;
Name
Kind
Type
Requirement
service
parameter
DrawerService
required
scope
parameter
PartScope
required
_options
parameter
DrawerConnectOptions
optional
return
return value
DrawerApi
n/a
Name
service
Kind
parameter
Type
DrawerService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
_options
Kind
parameter
Type
DrawerConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
DrawerApi
Requirement
n/a

drawerAnatomy

value
DeclarationView source
drawerAnatomyts
export declare const drawerAnatomy: {
  readonly scope: "drawer";
  readonly parts: readonly ["trigger", "backdrop", "positioner", "content", "title", "description", "close-trigger"];
};
Name
Kind
Type
Requirement
parts
property
readonly ["trigger", "backdrop", "positioner", "content", "title", "description", "close-trigger"]
required
scope
property
"drawer"
required
Name
parts
Kind
property
Type
readonly ["trigger", "backdrop", "positioner", "content", "title", "description", "close-trigger"]
Requirement
required
Name
scope
Kind
property
Type
"drawer"
Requirement
required

DrawerApi

type
DeclarationView source
DrawerApits
type DrawerApi = SheetApi;

DrawerChangeReason

type
DeclarationView source
DrawerChangeReasonts
type SheetChangeReason = SheetOpenReason | SheetCloseReason;

DrawerCloseReason

type
DeclarationView source
DrawerCloseReasonts
type SheetCloseReason = "escape" | "outside-click" | "close-trigger" | "programmatic";

DrawerCommand

type
DeclarationView source
DrawerCommandts
type SheetCommand = CommandObject & {
  readonly type: "OPEN_CHANGE_REQUEST";
  readonly open: boolean;
  readonly reason: SheetChangeReason;
};
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
type
property
string
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required
Name
type
Kind
property
Type
string
Requirement
required

DrawerCommandOptions

type
DeclarationView source
DrawerCommandOptionsts
type DrawerCommandOptions = SheetCommandOptions;

DrawerConnectOptions

type
DeclarationView source
DrawerConnectOptionsts
type DrawerConnectOptions = Record<string, never>;

DrawerContext

type
DeclarationView source
DrawerContextts
type SheetContext = {
  readonly mode: "controlled" | "uncontrolled";
};
Name
Kind
Type
Requirement
mode
property
"controlled" | "uncontrolled"
required
Name
mode
Kind
property
Type
"controlled" | "uncontrolled"
Requirement
required

DrawerEvent

type
DeclarationView source
DrawerEventts
type SheetEvent = {
  readonly type: "OPEN";
  readonly reason: SheetOpenReason;
} | {
  readonly type: "CLOSE";
  readonly reason: SheetCloseReason;
};

DrawerInput

type
DeclarationView source
DrawerInputts
type SheetInput = {
  readonly open?: boolean;
  readonly defaultOpen?: boolean;
  readonly dismissable?: boolean;
  readonly side?: SheetSide;
};
Name
Kind
Type
Requirement
defaultOpen
property
boolean
optional
dismissable
property
boolean
optional
open
property
boolean
optional
side
property
SheetSide
optional
Name
defaultOpen
Kind
property
Type
boolean
Requirement
optional
Name
dismissable
Kind
property
Type
boolean
Requirement
optional
Name
open
Kind
property
Type
boolean
Requirement
optional
Name
side
Kind
property
Type
SheetSide
Requirement
optional

DrawerMachine

type
DeclarationView source
DrawerMachinets
type SheetMachine = Machine<SheetInput, SheetStateValue, SheetContext, SheetEvent, SheetCommand>;

DrawerMount

type
DeclarationView source
DrawerMountts
type DrawerMount = SheetMount;

DrawerOpenChangeDetail

type
DeclarationView source
DrawerOpenChangeDetailts
type DrawerOpenChangeDetail = {
  readonly open: boolean;
  readonly reason: import("@grassroot/ui-machines/sheet").SheetChangeReason;
};
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
import("@grassroot/ui-machines/sheet").SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
import("@grassroot/ui-machines/sheet").SheetChangeReason
Requirement
required

DrawerOpenReason

type
DeclarationView source
DrawerOpenReasonts
type SheetOpenReason = "trigger" | "programmatic";

DrawerPart

type
DeclarationView source
DrawerPartts
type DrawerPart = (typeof drawerAnatomy.parts)[number];

DrawerService

type
DeclarationView source
DrawerServicets
type DrawerService = SheetService;

DrawerSide

type
DeclarationView source
DrawerSidets
type SheetSide = "left" | "right" | "bottom" | "top";

DrawerSnapshot

type
DeclarationView source
DrawerSnapshotts
type SheetSnapshot = Snapshot<SheetStateValue, SheetContext>;

DrawerStateValue

type
DeclarationView source
DrawerStateValuets
type SheetStateValue = "open" | "closed";

mountDrawer

function
DeclarationView source
mountDrawerts
declare function mountDrawer(container: HTMLElement, options?: MountDrawerOptions): DrawerMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountDrawerOptions
optional
return
return value
DrawerMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountDrawerOptions
Requirement
optional
Name
return
Kind
return value
Type
DrawerMount
Requirement
n/a

MountDrawerOptions

type
DeclarationView source
MountDrawerOptionsts
type MountDrawerOptions = MountSheetOptions;

runDrawerCommand

function
DeclarationView source
runDrawerCommandts
declare function runDrawerCommand(command: Parameters<typeof runSheetCommand>[0], scope: PartScope, options?: DrawerCommandOptions): void;
Name
Kind
Type
Requirement
command
parameter
Parameters<typeof runSheetCommand>[0]
required
scope
parameter
PartScope
required
options
parameter
DrawerCommandOptions
optional
return
return value
void
n/a
Name
command
Kind
parameter
Type
Parameters<typeof runSheetCommand>[0]
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
DrawerCommandOptions
Requirement
optional
Name
return
Kind
return value
Type
void
Requirement
n/a

sheetMachine

value
DeclarationView source
sheetMachinets
export declare const sheetMachine: SheetMachine;

sheetSelectors

value
DeclarationView source
sheetSelectorsts
export declare const sheetSelectors: {
  open: (snapshot: SheetSnapshot) => boolean;
};
Name
Kind
Type
Requirement
open
property
(snapshot: SheetSnapshot) => boolean
required
Name
open
Kind
property
Type
(snapshot: SheetSnapshot) => boolean
Requirement
required

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React example follows below.

React imports

@grassroot/ui-headless-react/drawerts
import { Backdrop, CloseTrigger, Content, Description, Drawer, Positioner, Root, Title } from "@grassroot/ui-headless-react/drawer"; // +1 more exports

Vue imports

@grassroot/ui-headless-vue/drawerts
<script setup lang="ts">
import { DrawerBackdrop, DrawerCloseTrigger, DrawerContent, DrawerDescription, DrawerPositioner, DrawerRoot, DrawerTitle, DrawerTrigger } from "@grassroot/ui-headless-vue/drawer";
</script>

Angular imports

@grassroot/ui-headless-angular/drawerts
import { Component } from "@angular/core";
import { GR_DRAWER_DECLARATIONS } from "@grassroot/ui-headless-angular/drawer";
 
@Component({ standalone: true, imports: [GR_DRAWER_DECLARATIONS], template: `<!-- compose the drawer parts here -->` })
export class Example {}

Svelte imports

@grassroot/ui-headless-svelte/drawerts
<script lang="ts">
  import { DrawerBackdrop, DrawerCloseTrigger, DrawerContent, DrawerDescription, DrawerPositioner, DrawerRoot, DrawerTitle, DrawerTrigger } from "@grassroot/ui-headless-svelte/drawer";
</script>

Solid imports

@grassroot/ui-headless-solid/drawerts
import { DrawerBackdrop, DrawerCloseTrigger, DrawerContent, DrawerDescription, DrawerPositioner, DrawerRoot, DrawerTitle, DrawerTrigger } from "@grassroot/ui-headless-solid/drawer";

@grassroot/ui-headless-react/drawer

React adapter

17 exports
View source packages/ui-headless/react/src/drawer/index.ts

Backdrop

value
DeclarationView source
Backdropts
export declare const Backdrop: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

CloseTrigger

value
DeclarationView source
CloseTriggerts
export declare const CloseTrigger: import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Content

value
DeclarationView source
Contentts
export declare const Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Description

value
DeclarationView source
Descriptionts
export declare const Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLParagraphElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Drawer

value
DeclarationView source
Drawerts
export declare const Drawer: {
  Root: typeof Root;
  Trigger: import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Backdrop: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Positioner: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Content: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLDivElement>>;
  Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLHeadingElement>>;
  Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
    readonly asChild?: boolean;
  } & import("react").RefAttributes<HTMLParagraphElement>>;
  CloseTrigger: import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
};
Name
Kind
Type
Requirement
Backdrop
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
required
CloseTrigger
property
import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>
required
Content
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
required
Description
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLParagraphElement>>
required
Positioner
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
required
Root
property
typeof Root
required
Title
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLHeadingElement>>
required
Trigger
property
import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>
required
Name
Backdrop
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
CloseTrigger
Kind
property
Type
import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required
Name
Content
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Description
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLParagraphElement>>
Requirement
required
Name
Positioner
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Root
Kind
property
Type
typeof Root
Requirement
required
Name
Title
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & { readonly asChild?: boolean; } & import("react").RefAttributes<HTMLHeadingElement>>
Requirement
required
Name
Trigger
Kind
property
Type
import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required

DrawerContext

value
DeclarationView source
DrawerContextts
export declare const DrawerContext: import("react").Context<SheetContextValue | null>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

DrawerOpenChangeDetail

interface
DeclarationView source
DrawerOpenChangeDetailts
interface DrawerOpenChangeDetail {
  readonly open: boolean;
  readonly reason: SheetChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required

DrawerRootProps

interface
DeclarationView source
DrawerRootPropsts
interface DrawerRootProps extends Pick<SheetInput, "open" | "defaultOpen" | "dismissable" | "side"> {
  readonly onOpenChange?: (detail: DrawerOpenChangeDetail) => void;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
children
property
ReactNode
optional
onOpenChange
property
(detail: DrawerOpenChangeDetail) => void
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
onOpenChange
Kind
property
Type
(detail: DrawerOpenChangeDetail) => void
Requirement
optional

DrawerTriggerProps

interface
DeclarationView source
DrawerTriggerPropsts
interface SheetTriggerProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional

Positioner

value
DeclarationView source
Positionerts
export declare const Positioner: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Root

function
DeclarationView source
Rootts
declare function Root(props: DrawerRootProps): import("react").JSX.Element;
Name
Kind
Type
Requirement
props
parameter
DrawerRootProps
required
return
return value
import("react").JSX.Element
n/a
Name
props
Kind
parameter
Type
DrawerRootProps
Requirement
required
Name
return
Kind
return value
Type
import("react").JSX.Element
Requirement
n/a

Title

value
DeclarationView source
Titlets
export declare const Title: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & {
  readonly asChild?: boolean;
} & import("react").RefAttributes<HTMLHeadingElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Trigger

value
DeclarationView source
Triggerts
export declare const Trigger: import("react").ForwardRefExoticComponent<SheetTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

useDrawer

function
DeclarationView source
useDrawerts
declare function useDrawer(input: SheetInput, options?: UseDrawerOptions): UseDrawerResult;
Name
Kind
Type
Requirement
input
parameter
SheetInput
required
options
parameter
UseDrawerOptions
optional
return
return value
UseDrawerResult
n/a
Name
input
Kind
parameter
Type
SheetInput
Requirement
required
Name
options
Kind
parameter
Type
UseDrawerOptions
Requirement
optional
Name
return
Kind
return value
Type
UseDrawerResult
Requirement
n/a

useDrawerContext

function
DeclarationView source
useDrawerContextts
declare function useSheetContext(part: string): SheetContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
SheetContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
SheetContextValue
Requirement
n/a

UseDrawerOptions

interface
DeclarationView source
UseDrawerOptionsts
interface UseDrawerOptions {
  readonly onOpenChange?: (detail: DrawerOpenChangeDetail) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: DrawerOpenChangeDetail) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: DrawerOpenChangeDetail) => void
Requirement
optional

UseDrawerResult

interface
DeclarationView source
UseDrawerResultts
interface UseDrawerResult {
  readonly service: DrawerService;
  readonly connector: DrawerApi;
  readonly scope: PartScope;
  readonly snapshot: SheetSnapshot;
}
Name
Kind
Type
Requirement
connector
property
DrawerApi
required
scope
property
PartScope
required
service
property
DrawerService
required
snapshot
property
SheetSnapshot
required
Name
connector
Kind
property
Type
DrawerApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
DrawerService
Requirement
required
Name
snapshot
Kind
property
Type
SheetSnapshot
Requirement
required

@grassroot/ui-headless-vue/drawer

Vue adapter

13 exports
View source packages/ui-headless/vue/src/drawer/index.ts

DrawerBackdrop

value
DeclarationView source
DrawerBackdropts
export declare const DrawerBackdrop: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerCloseTrigger

value
DeclarationView source
DrawerCloseTriggerts
export declare const DrawerCloseTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerContent

value
DeclarationView source
DrawerContentts
export declare const DrawerContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerDescription

value
DeclarationView source
DrawerDescriptionts
export declare const DrawerDescription: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerOpenChangeDetail

interface
DeclarationView source
DrawerOpenChangeDetailts
interface SheetOpenChangeDetail {
  readonly open: boolean;
  readonly reason: SheetChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required

DrawerPositioner

value
DeclarationView source
DrawerPositionerts
export declare const DrawerPositioner: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerRoot

value
DeclarationView source
DrawerRootts
export declare const DrawerRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<SheetInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<SheetInput["defaultOpen"]>;
    default: undefined;
  };
  dismissable: {
    type: PropType<SheetInput["dismissable"]>;
    default: undefined;
  };
  side: {
    type: PropType<SheetInput["side"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: SheetOpenChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  open: {
    type: PropType<SheetInput["open"]>;
    default: undefined;
  };
  defaultOpen: {
    type: PropType<SheetInput["defaultOpen"]>;
    default: undefined;
  };
  dismissable: {
    type: PropType<SheetInput["dismissable"]>;
    default: undefined;
  };
  side: {
    type: PropType<SheetInput["side"]>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: SheetOpenChangeDetail) => any) | undefined;
}>, {
  open: boolean | undefined;
  defaultOpen: boolean | undefined;
  dismissable: boolean | undefined;
  side: import("@grassroot/ui-machines/sheet").SheetSide | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerTitle

value
DeclarationView source
DrawerTitlets
export declare const DrawerTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

DrawerTrigger

value
DeclarationView source
DrawerTriggerts
export declare const DrawerTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

useDrawer

function
DeclarationView source
useDrawerts
declare function useSheet(input: SheetInput | (() => SheetInput), options?: UseSheetOptions, kind?: "sheet" | "drawer"): UseSheetResult;
Name
Kind
Type
Requirement
input
parameter
SheetInput | (() => SheetInput)
required
options
parameter
UseSheetOptions
optional
kind
parameter
"sheet" | "drawer"
optional
return
return value
UseSheetResult
n/a
Name
input
Kind
parameter
Type
SheetInput | (() => SheetInput)
Requirement
required
Name
options
Kind
parameter
Type
UseSheetOptions
Requirement
optional
Name
kind
Kind
parameter
Type
"sheet" | "drawer"
Requirement
optional
Name
return
Kind
return value
Type
UseSheetResult
Requirement
n/a

useDrawerContext

function
DeclarationView source
useDrawerContextts
declare function useSheetContext(part: string): SheetContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
SheetContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
SheetContextValue
Requirement
n/a

UseDrawerOptions

interface
DeclarationView source
UseDrawerOptionsts
interface UseSheetOptions {
  readonly onOpenChange?: (detail: SheetOpenChangeDetail) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: SheetOpenChangeDetail) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: SheetOpenChangeDetail) => void
Requirement
optional

UseDrawerResult

interface
DeclarationView source
UseDrawerResultts
interface UseSheetResult {
  readonly service: SheetService;
  readonly connector: SheetApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<SheetSnapshot>;
  readonly hasMounted: ShallowRef<boolean>;
}
Name
Kind
Type
Requirement
connector
property
SheetApi
required
hasMounted
property
ShallowRef<boolean>
required
scope
property
PartScope
required
service
property
SheetService
required
snapshot
property
ShallowRef<SheetSnapshot>
required
Name
connector
Kind
property
Type
SheetApi
Requirement
required
Name
hasMounted
Kind
property
Type
ShallowRef<boolean>
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
SheetService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<SheetSnapshot>
Requirement
required

@grassroot/ui-headless-angular/drawer

Angular adapter

16 exports
View source packages/ui-headless/angular/src/drawer/index.ts

createDrawerStore

function
DeclarationView source
createDrawerStorets
export declare function createSheetStore(initialInput: SheetInput, options?: CreateSheetStoreOptions, kind?: "sheet" | "drawer"): SheetStore;
Name
Kind
Type
Requirement
initialInput
parameter
SheetInput
required
options
parameter
CreateSheetStoreOptions
optional
kind
parameter
"sheet" | "drawer"
optional
return
return value
SheetStore
n/a
Name
initialInput
Kind
parameter
Type
SheetInput
Requirement
required
Name
options
Kind
parameter
Type
CreateSheetStoreOptions
Requirement
optional
Name
kind
Kind
parameter
Type
"sheet" | "drawer"
Requirement
optional
Name
return
Kind
return value
Type
SheetStore
Requirement
n/a

CreateDrawerStoreOptions

interface
DeclarationView source
CreateDrawerStoreOptionsts
export interface CreateSheetStoreOptions {
    readonly onOpenChange?: (detail: SheetOpenChangeDetail) => void;
    readonly onCommit?: () => void;
}
Name
Kind
Type
Requirement
onCommit
property
() => void
optional
onOpenChange
property
(detail: SheetOpenChangeDetail) => void
optional
Name
onCommit
Kind
property
Type
() => void
Requirement
optional
Name
onOpenChange
Kind
property
Type
(detail: SheetOpenChangeDetail) => void
Requirement
optional

DRAWER_STORE

value
DeclarationView source
DRAWER_STOREts
export declare const DRAWER_STORE: InjectionToken<SheetStore>;

DrawerOpenChangeDetail

interface
DeclarationView source
DrawerOpenChangeDetailts
export interface SheetOpenChangeDetail {
    readonly open: boolean;
    readonly reason: SheetChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required

DrawerStore

interface
DeclarationView source
DrawerStorets
export interface SheetStore {
    readonly service: SheetService;
    readonly connector: SheetApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: SheetInput): void;
    bindOpenChange?(handler: (detail: {
        open: boolean;
        reason: SheetChangeReason;
    }) => void): void;
}
Name
Kind
Type
Requirement
bindOpenChange
method
((handler: (detail: { open: boolean; reason: SheetChangeReason; }) => void) => void) | undefined
optional
connector
property
SheetApi
required
scope
property
PartScope
required
service
property
SheetService
required
start
method
() => void
required
stop
method
() => void
required
sync
method
(input: SheetInput) => void
required
version
property
WritableSignal<number>
required
Name
bindOpenChange
Kind
method
Type
((handler: (detail: { open: boolean; reason: SheetChangeReason; }) => void) => void) | undefined
Requirement
optional
Name
connector
Kind
property
Type
SheetApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
SheetService
Requirement
required
Name
start
Kind
method
Type
() => void
Requirement
required
Name
stop
Kind
method
Type
() => void
Requirement
required
Name
sync
Kind
method
Type
(input: SheetInput) => void
Requirement
required
Name
version
Kind
property
Type
WritableSignal<number>
Requirement
required

GR_DRAWER_DECLARATIONS

value
DeclarationView source
GR_DRAWER_DECLARATIONSts
export declare const GR_DRAWER_DECLARATIONS: readonly [typeof GrDrawerRoot, typeof GrDrawerTrigger, typeof GrDrawerOpen, typeof GrDrawerBackdrop, typeof GrDrawerPositioner, typeof GrDrawerContent, typeof GrDrawerTitle, typeof GrDrawerDescription, typeof GrDrawerCloseTrigger];

GrDrawerBackdrop

class
DeclarationView source
GrDrawerBackdropts
export declare class GrDrawerBackdrop extends GrSheetBackdrop {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerBackdrop, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerBackdrop, "[grDrawerBackdrop]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerBackdrop, "[grDrawerBackdrop]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerBackdrop, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerBackdrop, "[grDrawerBackdrop]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerBackdrop, never>
Requirement
required

GrDrawerCloseTrigger

class
DeclarationView source
GrDrawerCloseTriggerts
export declare class GrDrawerCloseTrigger extends GrSheetCloseTrigger {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerCloseTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerCloseTrigger, "[grDrawerCloseTrigger]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerCloseTrigger, "[grDrawerCloseTrigger]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerCloseTrigger, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerCloseTrigger, "[grDrawerCloseTrigger]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerCloseTrigger, never>
Requirement
required

GrDrawerContent

class
DeclarationView source
GrDrawerContentts
export declare class GrDrawerContent extends GrSheetContent {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerContent, "[grDrawerContent]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerContent, "[grDrawerContent]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerContent, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerContent, "[grDrawerContent]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerContent, never>
Requirement
required

GrDrawerDescription

class
DeclarationView source
GrDrawerDescriptionts
export declare class GrDrawerDescription extends GrSheetDescription {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerDescription, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerDescription, "[grDrawerDescription]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerDescription, "[grDrawerDescription]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerDescription, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerDescription, "[grDrawerDescription]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerDescription, never>
Requirement
required

GrDrawerOpen

class
DeclarationView source
GrDrawerOpents
export declare class GrDrawerOpen extends GrSheetOpen {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerOpen, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerOpen, "[grDrawerOpen]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerOpen, "[grDrawerOpen]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerOpen, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerOpen, "[grDrawerOpen]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerOpen, never>
Requirement
required

GrDrawerPositioner

class
DeclarationView source
GrDrawerPositionerts
export declare class GrDrawerPositioner extends GrSheetPositioner {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerPositioner, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerPositioner, "[grDrawerPositioner]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerPositioner, "[grDrawerPositioner]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerPositioner, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerPositioner, "[grDrawerPositioner]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerPositioner, never>
Requirement
required

GrDrawerRoot

class
DeclarationView source
GrDrawerRootts
export declare class GrDrawerRoot extends SheetRootBase {
    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
    readonly defaultOpen: import("@angular/core").InputSignal<boolean | undefined>;
    readonly dismissable: import("@angular/core").InputSignal<boolean | undefined>;
    readonly side: import("@angular/core").InputSignal<import("@grassroot/ui-machines/sheet").SheetSide | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<SheetOpenChangeDetail>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerRoot, "[grDrawerRoot]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>;
}
Name
Kind
Type
Requirement
defaultOpen
property
import("@angular/core").InputSignal<boolean | undefined>
required
dismissable
property
import("@angular/core").InputSignal<boolean | undefined>
required
open
property
import("@angular/core").InputSignal<boolean | undefined>
required
openChange
property
import("@angular/core").OutputEmitterRef<SheetOpenChangeDetail>
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerRoot, "[grDrawerRoot]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerRoot, never>
required
side
property
import("@angular/core").InputSignal<import("@grassroot/ui-machines/sheet").SheetSide | undefined>
required
Name
defaultOpen
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
dismissable
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
open
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
openChange
Kind
property
Type
import("@angular/core").OutputEmitterRef<SheetOpenChangeDetail>
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerRoot, "[grDrawerRoot]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dismissable": { "alias": "dismissable"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerRoot, never>
Requirement
required
Name
side
Kind
property
Type
import("@angular/core").InputSignal<import("@grassroot/ui-machines/sheet").SheetSide | undefined>
Requirement
required

GrDrawerTitle

class
DeclarationView source
GrDrawerTitlets
export declare class GrDrawerTitle extends GrSheetTitle {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerTitle, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerTitle, "[grDrawerTitle]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerTitle, "[grDrawerTitle]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerTitle, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerTitle, "[grDrawerTitle]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerTitle, never>
Requirement
required

GrDrawerTrigger

class
DeclarationView source
GrDrawerTriggerts
export declare class GrDrawerTrigger extends GrSheetTrigger {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrDrawerTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrDrawerTrigger, "[grDrawerTrigger]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrDrawerTrigger, "[grDrawerTrigger]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrDrawerTrigger, never>
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrDrawerTrigger, "[grDrawerTrigger]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrDrawerTrigger, never>
Requirement
required

provideDrawerStore

function
DeclarationView source
provideDrawerStorets
export declare function provideDrawerStore(): Provider;
Name
Kind
Type
Requirement
return
return value
Provider
n/a
Name
return
Kind
return value
Type
Provider
Requirement
n/a

@grassroot/ui-headless-svelte/drawer

Svelte adapter

13 exports
View source packages/ui-headless/svelte/src/drawer/index.ts

createDrawer

function
DeclarationView source
createDrawerts
export declare function createDrawer(inputGetter: () => SheetInput, options?: UseDrawerOptions): UseDrawerResult;
Name
Kind
Type
Requirement
inputGetter
parameter
() => SheetInput
required
options
parameter
UseDrawerOptions
optional
return
return value
UseDrawerResult
n/a
Name
inputGetter
Kind
parameter
Type
() => SheetInput
Requirement
required
Name
options
Kind
parameter
Type
UseDrawerOptions
Requirement
optional
Name
return
Kind
return value
Type
UseDrawerResult
Requirement
n/a

DrawerBackdrop

value
DeclarationView source
DrawerBackdropts
export declare const DrawerBackdrop: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerCloseTrigger

value
DeclarationView source
DrawerCloseTriggerts
export declare const DrawerCloseTrigger: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerContent

value
DeclarationView source
DrawerContentts
export declare const DrawerContent: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerDescription

value
DeclarationView source
DrawerDescriptionts
export declare const DrawerDescription: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerOpenChangeDetail

interface
DeclarationView source
DrawerOpenChangeDetailts
export interface DrawerOpenChangeDetail {
    readonly open: boolean;
    readonly reason: SheetChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required

DrawerPositioner

value
DeclarationView source
DrawerPositionerts
export declare const DrawerPositioner: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerRoot

value
DeclarationView source
DrawerRootts
export declare const DrawerRoot: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerTitle

value
DeclarationView source
DrawerTitlets
export declare const DrawerTitle: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

DrawerTrigger

value
DeclarationView source
DrawerTriggerts
export declare const DrawerTrigger: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

useDrawerContext

function
DeclarationView source
useDrawerContextts
export declare function useSheetContext(part: string): SheetContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
SheetContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
SheetContextValue
Requirement
n/a

UseDrawerOptions

interface
DeclarationView source
UseDrawerOptionsts
export interface UseDrawerOptions {
    readonly onOpenChange?: (detail: DrawerOpenChangeDetail) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: DrawerOpenChangeDetail) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: DrawerOpenChangeDetail) => void
Requirement
optional

UseDrawerResult

interface
DeclarationView source
UseDrawerResultts
export interface UseDrawerResult {
    readonly service: DrawerService;
    readonly connector: DrawerApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
DrawerApi
required
scope
property
PartScope
required
service
property
DrawerService
required
version
property
() => number
required
Name
connector
Kind
property
Type
DrawerApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
DrawerService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

@grassroot/ui-headless-solid/drawer

Solid adapter

21 exports
View source packages/ui-headless/solid/src/drawer/index.ts

DrawerBackdrop

value
DeclarationView source
DrawerBackdropts
export declare const DrawerBackdrop: typeof SheetBackdrop;
Name
Kind
Type
Requirement
props
parameter
SheetBackdropProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetBackdropProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerBackdropProps

interface
DeclarationView source
DrawerBackdropPropsts
export interface SheetBackdropProps extends JSX.HTMLAttributes<HTMLDivElement>, Common {
}

DrawerCloseTrigger

value
DeclarationView source
DrawerCloseTriggerts
export declare const DrawerCloseTrigger: typeof SheetCloseTrigger;
Name
Kind
Type
Requirement
props
parameter
SheetCloseTriggerProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetCloseTriggerProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerCloseTriggerProps

interface
DeclarationView source
DrawerCloseTriggerPropsts
export interface SheetCloseTriggerProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement>, Common {
}

DrawerContent

value
DeclarationView source
DrawerContentts
export declare const DrawerContent: typeof SheetContent;
Name
Kind
Type
Requirement
props
parameter
SheetContentProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetContentProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerContentProps

interface
DeclarationView source
DrawerContentPropsts
export interface SheetContentProps extends JSX.HTMLAttributes<HTMLDivElement>, Common {
}

DrawerDescription

value
DeclarationView source
DrawerDescriptionts
export declare const DrawerDescription: typeof SheetDescription;
Name
Kind
Type
Requirement
props
parameter
SheetDescriptionProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetDescriptionProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerDescriptionProps

interface
DeclarationView source
DrawerDescriptionPropsts
export interface SheetDescriptionProps extends JSX.HTMLAttributes<HTMLParagraphElement>, Common {
}

DrawerOpenChangeDetail

interface
DeclarationView source
DrawerOpenChangeDetailts
export interface SheetOpenChangeDetail {
    readonly open: boolean;
    readonly reason: SheetChangeReason;
}
Name
Kind
Type
Requirement
open
property
boolean
required
reason
property
SheetChangeReason
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
reason
Kind
property
Type
SheetChangeReason
Requirement
required

DrawerPositioner

value
DeclarationView source
DrawerPositionerts
export declare const DrawerPositioner: typeof SheetPositioner;
Name
Kind
Type
Requirement
props
parameter
SheetPositionerProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetPositionerProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerPositionerProps

interface
DeclarationView source
DrawerPositionerPropsts
export interface SheetPositionerProps extends JSX.HTMLAttributes<HTMLDivElement>, Common {
}

DrawerRoot

value
DeclarationView source
DrawerRootts
export declare const DrawerRoot: (props: SheetRootProps) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
SheetRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerRootProps

interface
DeclarationView source
DrawerRootPropsts
export interface SheetRootProps {
    readonly open?: SheetInput["open"];
    readonly defaultOpen?: SheetInput["defaultOpen"];
    readonly dismissable?: SheetInput["dismissable"];
    readonly side?: SheetInput["side"];
    readonly onOpenChange?: (detail: SheetOpenChangeDetail) => void;
    readonly children?: JSX.Element;
}
Name
Kind
Type
Requirement
children
property
JSX.Element
optional
defaultOpen
property
SheetInput["defaultOpen"]
optional
dismissable
property
SheetInput["dismissable"]
optional
onOpenChange
property
(detail: SheetOpenChangeDetail) => void
optional
open
property
SheetInput["open"]
optional
side
property
SheetInput["side"]
optional
Name
children
Kind
property
Type
JSX.Element
Requirement
optional
Name
defaultOpen
Kind
property
Type
SheetInput["defaultOpen"]
Requirement
optional
Name
dismissable
Kind
property
Type
SheetInput["dismissable"]
Requirement
optional
Name
onOpenChange
Kind
property
Type
(detail: SheetOpenChangeDetail) => void
Requirement
optional
Name
open
Kind
property
Type
SheetInput["open"]
Requirement
optional
Name
side
Kind
property
Type
SheetInput["side"]
Requirement
optional

DrawerTitle

value
DeclarationView source
DrawerTitlets
export declare const DrawerTitle: typeof SheetTitle;
Name
Kind
Type
Requirement
props
parameter
SheetTitleProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetTitleProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerTitleProps

interface
DeclarationView source
DrawerTitlePropsts
export interface SheetTitleProps extends JSX.HTMLAttributes<HTMLHeadingElement>, Common {
}

DrawerTrigger

value
DeclarationView source
DrawerTriggerts
export declare const DrawerTrigger: typeof SheetTrigger;
Name
Kind
Type
Requirement
props
parameter
SheetTriggerProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetTriggerProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

DrawerTriggerProps

interface
DeclarationView source
DrawerTriggerPropsts
export interface SheetTriggerProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement>, Common {
}

useDrawer

function
DeclarationView source
useDrawerts
export declare function useSheet(input: Accessor<SheetInput>, options?: UseSheetOptions, kind?: SheetKind): UseSheetResult;
Name
Kind
Type
Requirement
input
parameter
Accessor<SheetInput>
required
options
parameter
UseSheetOptions
optional
kind
parameter
SheetKind
optional
return
return value
UseSheetResult
n/a
Name
input
Kind
parameter
Type
Accessor<SheetInput>
Requirement
required
Name
options
Kind
parameter
Type
UseSheetOptions
Requirement
optional
Name
kind
Kind
parameter
Type
SheetKind
Requirement
optional
Name
return
Kind
return value
Type
UseSheetResult
Requirement
n/a

useDrawerContext

function
DeclarationView source
useDrawerContextts
export declare function useSheetContext(part: string): SheetContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
SheetContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
SheetContextValue
Requirement
n/a

UseDrawerOptions

interface
DeclarationView source
UseDrawerOptionsts
export interface UseSheetOptions {
    readonly onOpenChange?: (detail: SheetOpenChangeDetail) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: SheetOpenChangeDetail) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: SheetOpenChangeDetail) => void
Requirement
optional

UseDrawerResult

interface
DeclarationView source
UseDrawerResultts
export interface UseSheetResult {
    readonly service: SheetService;
    readonly connector: SheetApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<SheetSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
SheetApi
required
scope
property
PartScope
required
service
property
SheetService
required
snapshot
property
Accessor<SheetSnapshot>
required
Name
connector
Kind
property
Type
SheetApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
SheetService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<SheetSnapshot>
Requirement
required