grassroot
Install

DocsAPI referenceHeadlesssheet

sheet 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.

Machine APIPlatform contract

@grassroot/ui-headless-core/sheet

Core connector and vanilla API

25 exports
View source packages/ui-headless/core/src/sheet/index.ts

activateSheetManagers

function

Shared manager activation used by both Sheet and Drawer.

DeclarationView source
activateSheetManagersts
declare function activateSheetManagers(service: SheetService, scope: PartScope, doc: Document, errorName?: string): () => void;
Name
Kind
Type
Requirement
service
parameter
SheetService
required
scope
parameter
PartScope
required
doc
parameter
Document
required
errorName
parameter
string
optional
return
return value
() => void
n/a
Name
service
Kind
parameter
Type
SheetService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
doc
Kind
parameter
Type
Document
Requirement
required
Name
errorName
Kind
parameter
Type
string
Requirement
optional
Name
return
Kind
return value
Type
() => void
Requirement
n/a

connectSheet

function
DeclarationView source
connectSheetts
declare function connectSheet(service: SheetService, scope: PartScope, _options?: SheetConnectOptions): SheetApi;
Name
Kind
Type
Requirement
service
parameter
SheetService
required
scope
parameter
PartScope
required
_options
parameter
SheetConnectOptions
optional
return
return value
SheetApi
n/a
Name
service
Kind
parameter
Type
SheetService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
_options
Kind
parameter
Type
SheetConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
SheetApi
Requirement
n/a

mountSheet

function
DeclarationView source
mountSheetts
declare function mountSheet(container: HTMLElement, options?: MountSheetOptions): SheetMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountSheetOptions
optional
return
return value
SheetMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountSheetOptions
Requirement
optional
Name
return
Kind
return value
Type
SheetMount
Requirement
n/a

MountSheetOptions

interface
DeclarationView source
MountSheetOptionsts
interface MountSheetOptions extends SheetInput {
  readonly onOpenChange?: (detail: SheetOpenChangeDetail) => void;
  readonly renderTrigger?: (button: HTMLButtonElement) => void;
  readonly renderContent?: (panel: HTMLDivElement) => void;
  readonly renderTitle?: (heading: HTMLHeadingElement) => void;
  readonly renderDescription?: (paragraph: HTMLParagraphElement) => void;
  readonly renderCloseTrigger?: (button: HTMLButtonElement) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: SheetOpenChangeDetail) => void
optional
renderCloseTrigger
property
(button: HTMLButtonElement) => void
optional
renderContent
property
(panel: HTMLDivElement) => void
optional
renderDescription
property
(paragraph: HTMLParagraphElement) => void
optional
renderTitle
property
(heading: HTMLHeadingElement) => void
optional
renderTrigger
property
(button: HTMLButtonElement) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: SheetOpenChangeDetail) => void
Requirement
optional
Name
renderCloseTrigger
Kind
property
Type
(button: HTMLButtonElement) => void
Requirement
optional
Name
renderContent
Kind
property
Type
(panel: HTMLDivElement) => void
Requirement
optional
Name
renderDescription
Kind
property
Type
(paragraph: HTMLParagraphElement) => void
Requirement
optional
Name
renderTitle
Kind
property
Type
(heading: HTMLHeadingElement) => void
Requirement
optional
Name
renderTrigger
Kind
property
Type
(button: HTMLButtonElement) => void
Requirement
optional

runSheetCommand

function
DeclarationView source
runSheetCommandts
declare function runSheetCommand(command: SheetCommand, _scope: PartScope, options?: SheetCommandOptions): void;
Name
Kind
Type
Requirement
command
parameter
SheetCommand
required
_scope
parameter
PartScope
required
options
parameter
SheetCommandOptions
optional
return
return value
void
n/a
Name
command
Kind
parameter
Type
SheetCommand
Requirement
required
Name
_scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
SheetCommandOptions
Requirement
optional
Name
return
Kind
return value
Type
void
Requirement
n/a

sheetAnatomy

value
DeclarationView source
sheetAnatomyts
export declare const sheetAnatomy: {
  readonly scope: "sheet";
  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
"sheet"
required
Name
parts
Kind
property
Type
readonly ["trigger", "backdrop", "positioner", "content", "title", "description", "close-trigger"]
Requirement
required
Name
scope
Kind
property
Type
"sheet"
Requirement
required

SheetApi

interface
DeclarationView source
SheetApits
interface SheetApi {
  triggerProps(): PartProps;
  backdropProps(): PartProps;
  positionerProps(): PartProps;
  contentProps(): PartProps;
  titleProps(): PartProps;
  descriptionProps(): PartProps;
  closeTriggerProps(): PartProps;
  readonly open: boolean;
}
Name
Kind
Type
Requirement
backdropProps
method
() => PartProps
required
closeTriggerProps
method
() => PartProps
required
contentProps
method
() => PartProps
required
descriptionProps
method
() => PartProps
required
open
property
boolean
required
positionerProps
method
() => PartProps
required
titleProps
method
() => PartProps
required
triggerProps
method
() => PartProps
required
Name
backdropProps
Kind
method
Type
() => PartProps
Requirement
required
Name
closeTriggerProps
Kind
method
Type
() => PartProps
Requirement
required
Name
contentProps
Kind
method
Type
() => PartProps
Requirement
required
Name
descriptionProps
Kind
method
Type
() => PartProps
Requirement
required
Name
open
Kind
property
Type
boolean
Requirement
required
Name
positionerProps
Kind
method
Type
() => PartProps
Requirement
required
Name
titleProps
Kind
method
Type
() => PartProps
Requirement
required
Name
triggerProps
Kind
method
Type
() => PartProps
Requirement
required

SheetChangeReason

type
DeclarationView source
SheetChangeReasonts
type SheetChangeReason = SheetOpenReason | SheetCloseReason;

SheetCloseReason

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

SheetCommand

type
DeclarationView source
SheetCommandts
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

SheetCommandOptions

interface
DeclarationView source
SheetCommandOptionsts
interface SheetCommandOptions {
  readonly onOpenChange?: (detail: {
    open: boolean;
    reason: SheetChangeReason;
  }) => void;
}
Name
Kind
Type
Requirement
onOpenChange
property
(detail: { open: boolean; reason: SheetChangeReason; }) => void
optional
Name
onOpenChange
Kind
property
Type
(detail: { open: boolean; reason: SheetChangeReason; }) => void
Requirement
optional

SheetConnectOptions

interface
DeclarationView source
SheetConnectOptionsts
interface SheetConnectOptions {}

SheetContext

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

SheetEvent

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

SheetInput

type
DeclarationView source
SheetInputts
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

sheetMachine

value
DeclarationView source
sheetMachinets
export declare const sheetMachine: SheetMachine;

SheetMount

interface
DeclarationView source
SheetMountts
interface SheetMount {
  readonly service: SheetService;
  readonly connector: SheetApi;
  readonly root: HTMLElement;
  readonly trigger: HTMLButtonElement;
  destroy(): void;
}
Name
Kind
Type
Requirement
connector
property
SheetApi
required
destroy
method
() => void
required
root
property
HTMLElement
required
service
property
SheetService
required
trigger
property
HTMLButtonElement
required
Name
connector
Kind
property
Type
SheetApi
Requirement
required
Name
destroy
Kind
method
Type
() => void
Requirement
required
Name
root
Kind
property
Type
HTMLElement
Requirement
required
Name
service
Kind
property
Type
SheetService
Requirement
required
Name
trigger
Kind
property
Type
HTMLButtonElement
Requirement
required

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetOpenReason

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

SheetPart

type
DeclarationView source
SheetPartts
type SheetPart = (typeof sheetAnatomy.parts)[number];

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

SheetService

type
DeclarationView source
SheetServicets
type SheetService = Service<SheetInput, SheetStateValue, SheetContext, SheetEvent, SheetCommand>;

SheetSide

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

SheetSnapshot

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

SheetStateValue

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

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/sheetts
import { Backdrop, CloseTrigger, Content, Description, Positioner, Root, Sheet, Title } from "@grassroot/ui-headless-react/sheet"; // +1 more exports

Vue imports

@grassroot/ui-headless-vue/sheetts
<script setup lang="ts">
import { SheetBackdrop, SheetCloseTrigger, SheetContent, SheetDescription, SheetPositioner, SheetRoot, SheetTitle, SheetTrigger } from "@grassroot/ui-headless-vue/sheet";
</script>

Angular imports

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

Svelte imports

@grassroot/ui-headless-svelte/sheetts
<script lang="ts">
  import { SheetBackdrop, SheetCloseTrigger, SheetContent, SheetDescription, SheetPositioner, SheetRoot, SheetTitle, SheetTrigger } from "@grassroot/ui-headless-svelte/sheet";
</script>

Solid imports

@grassroot/ui-headless-solid/sheetts
import { SheetBackdrop, SheetCloseTrigger, SheetContent, SheetDescription, SheetPositioner, SheetRoot, SheetTitle, SheetTrigger } from "@grassroot/ui-headless-solid/sheet";

@grassroot/ui-headless-react/sheet

React adapter

18 exports
View source packages/ui-headless/react/src/sheet/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

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: SheetRootProps): import("react").JSX.Element;
Name
Kind
Type
Requirement
props
parameter
SheetRootProps
required
return
return value
import("react").JSX.Element
n/a
Name
props
Kind
parameter
Type
SheetRootProps
Requirement
required
Name
return
Kind
return value
Type
import("react").JSX.Element
Requirement
n/a

Sheet

value
DeclarationView source
Sheetts
export declare const Sheet: {
  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

SheetContext

value
DeclarationView source
SheetContextts
export declare const SheetContext: 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

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetRootProps

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

SheetTriggerProps

interface
DeclarationView source
SheetTriggerPropsts
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

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

useServiceVersion

function

Subscribes a component to a service's committed-snapshot version.

DeclarationView source
useServiceVersionts
declare function useServiceVersion<S extends Service<any, any, any, any, any, any>>(service: S): ReturnType<S["getSnapshot"]>;
Name
Kind
Type
Requirement
service
parameter
S
required
return
return value
ReturnType<S["getSnapshot"]>
n/a
Name
service
Kind
parameter
Type
S
Requirement
required
Name
return
Kind
return value
Type
ReturnType<S["getSnapshot"]>
Requirement
n/a

useSheet

function
DeclarationView source
useSheetts
declare function useSheet(input: SheetInput, options?: UseSheetOptions): UseSheetResult;
Name
Kind
Type
Requirement
input
parameter
SheetInput
required
options
parameter
UseSheetOptions
optional
return
return value
UseSheetResult
n/a
Name
input
Kind
parameter
Type
SheetInput
Requirement
required
Name
options
Kind
parameter
Type
UseSheetOptions
Requirement
optional
Name
return
Kind
return value
Type
UseSheetResult
Requirement
n/a

useSheetContext

function
DeclarationView source
useSheetContextts
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

UseSheetOptions

interface
DeclarationView source
UseSheetOptionsts
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

UseSheetResult

interface
DeclarationView source
UseSheetResultts
interface UseSheetResult {
  readonly service: SheetService;
  readonly connector: SheetApi;
  readonly scope: PartScope;
  readonly snapshot: SheetSnapshot;
}
Name
Kind
Type
Requirement
connector
property
SheetApi
required
scope
property
PartScope
required
service
property
SheetService
required
snapshot
property
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
SheetSnapshot
Requirement
required

@grassroot/ui-headless-vue/sheet

Vue adapter

14 exports
View source packages/ui-headless/vue/src/sheet/index.ts

provideSheetContext

function
DeclarationView source
provideSheetContextts
declare function provideSheetContext(value: SheetContextValue): void;
Name
Kind
Type
Requirement
value
parameter
SheetContextValue
required
return
return value
void
n/a
Name
value
Kind
parameter
Type
SheetContextValue
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

SheetBackdrop

value
DeclarationView source
SheetBackdropts
export declare const SheetBackdrop: 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>;

SheetCloseTrigger

value
DeclarationView source
SheetCloseTriggerts
export declare const SheetCloseTrigger: 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>;

SheetContent

value
DeclarationView source
SheetContentts
export declare const SheetContent: 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>;

SheetDescription

value
DeclarationView source
SheetDescriptionts
export declare const SheetDescription: 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>;

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetPositioner

value
DeclarationView source
SheetPositionerts
export declare const SheetPositioner: 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>;

SheetRoot

value
DeclarationView source
SheetRootts
export declare const SheetRoot: 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>;

SheetTitle

value
DeclarationView source
SheetTitlets
export declare const SheetTitle: 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>;

SheetTrigger

value
DeclarationView source
SheetTriggerts
export declare const SheetTrigger: 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>;

useSheet

function
DeclarationView source
useSheetts
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

useSheetContext

function
DeclarationView source
useSheetContextts
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

UseSheetOptions

interface
DeclarationView source
UseSheetOptionsts
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

UseSheetResult

interface
DeclarationView source
UseSheetResultts
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/sheet

Angular adapter

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

createSheetStore

function
DeclarationView source
createSheetStorets
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

CreateSheetStoreOptions

interface
DeclarationView source
CreateSheetStoreOptionsts
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

GR_SHEET_DECLARATIONS

value
DeclarationView source
GR_SHEET_DECLARATIONSts
export declare const GR_SHEET_DECLARATIONS: readonly [typeof GrSheetRoot, typeof GrSheetTrigger, typeof GrSheetOpen, typeof GrSheetBackdrop, typeof GrSheetPositioner, typeof GrSheetContent, typeof GrSheetTitle, typeof GrSheetDescription, typeof GrSheetCloseTrigger];

GrSheetBackdrop

class
DeclarationView source
GrSheetBackdropts
export declare class GrSheetBackdrop implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetBackdrop, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetBackdrop, "[grSheetBackdrop]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetBackdrop, "[grSheetBackdrop]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetBackdrop, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetBackdrop, "[grSheetBackdrop]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetBackdrop, never>
Requirement
required

GrSheetCloseTrigger

class
DeclarationView source
GrSheetCloseTriggerts
export declare class GrSheetCloseTrigger implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetCloseTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetCloseTrigger, "[grSheetCloseTrigger]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetCloseTrigger, "[grSheetCloseTrigger]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetCloseTrigger, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetCloseTrigger, "[grSheetCloseTrigger]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetCloseTrigger, never>
Requirement
required

GrSheetContent

class
DeclarationView source
GrSheetContentts
export declare class GrSheetContent implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetContent, "[grSheetContent]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetContent, "[grSheetContent]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetContent, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetContent, "[grSheetContent]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetContent, never>
Requirement
required

GrSheetDescription

class
DeclarationView source
GrSheetDescriptionts
export declare class GrSheetDescription implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetDescription, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetDescription, "[grSheetDescription]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetDescription, "[grSheetDescription]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetDescription, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetDescription, "[grSheetDescription]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetDescription, never>
Requirement
required

GrSheetOpen

class
DeclarationView source
GrSheetOpents
export declare class GrSheetOpen implements OnDestroy {
    private store;
    private template;
    private view;
    private shown;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetOpen, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetOpen, "[grSheetOpen]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetOpen, "[grSheetOpen]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetOpen, never>
required
shown
property
any
required
store
property
any
required
template
property
any
required
view
property
any
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetOpen, "[grSheetOpen]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetOpen, never>
Requirement
required
Name
shown
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required
Name
template
Kind
property
Type
any
Requirement
required
Name
view
Kind
property
Type
any
Requirement
required

GrSheetPositioner

class
DeclarationView source
GrSheetPositionerts
export declare class GrSheetPositioner implements OnDestroy {
    protected readonly positionerElement: any;
    private readonly renderer;
    private readonly store;
    private clean;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetPositioner, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetPositioner, "[grSheetPositioner]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetPositioner, "[grSheetPositioner]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetPositioner, never>
required
positionerElement
property
any
required
renderer
property
any
required
store
property
any
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetPositioner, "[grSheetPositioner]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetPositioner, never>
Requirement
required
Name
positionerElement
Kind
property
Type
any
Requirement
required
Name
renderer
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrSheetRoot

class
DeclarationView source
GrSheetRootts
export declare class GrSheetRoot 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<GrSheetRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetRoot, "[grSheetRoot]", 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<GrSheetRoot, "[grSheetRoot]", 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<GrSheetRoot, 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<GrSheetRoot, "[grSheetRoot]", 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<GrSheetRoot, never>
Requirement
required
Name
side
Kind
property
Type
import("@angular/core").InputSignal<import("@grassroot/ui-machines/sheet").SheetSide | undefined>
Requirement
required

GrSheetTitle

class
DeclarationView source
GrSheetTitlets
export declare class GrSheetTitle implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetTitle, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetTitle, "[grSheetTitle]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetTitle, "[grSheetTitle]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetTitle, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetTitle, "[grSheetTitle]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetTitle, never>
Requirement
required

GrSheetTrigger

class
DeclarationView source
GrSheetTriggerts
export declare class GrSheetTrigger implements OnDestroy {
    private clean;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrSheetTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrSheetTrigger, "[grSheetTrigger]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
clean
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrSheetTrigger, "[grSheetTrigger]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrSheetTrigger, never>
required
Name
clean
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrSheetTrigger, "[grSheetTrigger]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrSheetTrigger, never>
Requirement
required

provideSheetStore

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

SHEET_STORE

value
DeclarationView source
SHEET_STOREts
export declare const SHEET_STORE: InjectionToken<SheetStore>;

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetStore

interface
DeclarationView source
SheetStorets
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

@grassroot/ui-headless-svelte/sheet

Svelte adapter

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

createSheet

function
DeclarationView source
createSheetts
export declare function createSheet(inputGetter: () => SheetInput, options?: UseSheetOptions, kind?: "sheet" | "drawer"): UseSheetResult;
Name
Kind
Type
Requirement
inputGetter
parameter
() => SheetInput
required
options
parameter
UseSheetOptions
optional
kind
parameter
"sheet" | "drawer"
optional
return
return value
UseSheetResult
n/a
Name
inputGetter
Kind
parameter
Type
() => 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

SheetBackdrop

value
DeclarationView source
SheetBackdropts
export declare const SheetBackdrop: 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

SheetCloseTrigger

value
DeclarationView source
SheetCloseTriggerts
export declare const SheetCloseTrigger: 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

SheetContent

value
DeclarationView source
SheetContentts
export declare const SheetContent: 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

SheetDescription

value
DeclarationView source
SheetDescriptionts
export declare const SheetDescription: 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

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetPositioner

value
DeclarationView source
SheetPositionerts
export declare const SheetPositioner: 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

SheetRoot

value
DeclarationView source
SheetRootts
export declare const SheetRoot: 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

SheetTitle

value
DeclarationView source
SheetTitlets
export declare const SheetTitle: 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

SheetTrigger

value
DeclarationView source
SheetTriggerts
export declare const SheetTrigger: 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

useSheetContext

function
DeclarationView source
useSheetContextts
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

UseSheetOptions

interface
DeclarationView source
UseSheetOptionsts
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

UseSheetResult

interface
DeclarationView source
UseSheetResultts
export interface UseSheetResult {
    readonly service: SheetService;
    readonly connector: SheetApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
SheetApi
required
scope
property
PartScope
required
service
property
SheetService
required
version
property
() => number
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
version
Kind
property
Type
() => number
Requirement
required

@grassroot/ui-headless-solid/sheet

Solid adapter

22 exports
View source packages/ui-headless/solid/src/sheet/index.ts

SheetBackdrop

function
DeclarationView source
SheetBackdropts
export declare function SheetBackdrop(props: SheetBackdropProps): JSX.Element;
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

SheetBackdropProps

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

SheetCloseTrigger

function
DeclarationView source
SheetCloseTriggerts
export declare function SheetCloseTrigger(props: SheetCloseTriggerProps): JSX.Element;
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

SheetCloseTriggerProps

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

SheetContent

function
DeclarationView source
SheetContentts
export declare function SheetContent(props: SheetContentProps): JSX.Element;
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

SheetContentProps

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

SheetContext

value
DeclarationView source
SheetContextts
export declare const SheetContext: import("solid-js").Context<SheetContextValue | undefined>;

SheetDescription

function
DeclarationView source
SheetDescriptionts
export declare function SheetDescription(props: SheetDescriptionProps): JSX.Element;
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

SheetDescriptionProps

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

SheetOpenChangeDetail

interface
DeclarationView source
SheetOpenChangeDetailts
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

SheetPositioner

function
DeclarationView source
SheetPositionerts
export declare function SheetPositioner(props: SheetPositionerProps): JSX.Element;
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

SheetPositionerProps

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

SheetRoot

value
DeclarationView source
SheetRootts
export declare const SheetRoot: (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

SheetRootProps

interface
DeclarationView source
SheetRootPropsts
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

SheetTitle

function
DeclarationView source
SheetTitlets
export declare function SheetTitle(props: SheetTitleProps): JSX.Element;
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

SheetTitleProps

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

SheetTrigger

function
DeclarationView source
SheetTriggerts
export declare function SheetTrigger(props: SheetTriggerProps): JSX.Element;
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

SheetTriggerProps

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

useSheet

function
DeclarationView source
useSheetts
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

useSheetContext

function
DeclarationView source
useSheetContextts
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

UseSheetOptions

interface
DeclarationView source
UseSheetOptionsts
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

UseSheetResult

interface
DeclarationView source
UseSheetResultts
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