grassroot
Install

DocsAPI referenceHeadlesslog-stream

log-stream 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/log-stream

Core connector and vanilla API

31 exports
View source packages/ui-headless/core/src/log-stream/index.ts

connectLogStream

function
DeclarationView source
connectLogStreamts
declare function connectLogStream(service: LogStreamService, scope: PartScope, _options?: LogStreamConnectOptions): LogStreamApi;
Name
Kind
Type
Requirement
service
parameter
LogStreamService
required
scope
parameter
PartScope
required
_options
parameter
LogStreamConnectOptions
optional
return
return value
LogStreamApi
n/a
Name
service
Kind
parameter
Type
LogStreamService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
_options
Kind
parameter
Type
LogStreamConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
LogStreamApi
Requirement
n/a

createLogStreamScheduledRunner

function
DeclarationView source
createLogStreamScheduledRunnerts
declare function createLogStreamScheduledRunner(scheduler: Scheduler, next: RunCommand<LogStreamCommand, LogStreamEvent> | undefined, stamp: () => string): RunCommand<LogStreamCommand, LogStreamEvent>;
Name
Kind
Type
Requirement
scheduler
parameter
Scheduler
required
next
parameter
RunCommand<LogStreamCommand, LogStreamEvent> | undefined
required
stamp
parameter
() => string
required
return
return value
RunCommand<LogStreamCommand, LogStreamEvent>
n/a
Name
scheduler
Kind
parameter
Type
Scheduler
Requirement
required
Name
next
Kind
parameter
Type
RunCommand<LogStreamCommand, LogStreamEvent> | undefined
Requirement
required
Name
stamp
Kind
parameter
Type
() => string
Requirement
required
Name
return
Kind
return value
Type
RunCommand<LogStreamCommand, LogStreamEvent>
Requirement
n/a

LOG_STREAM_DEFAULT_FILTERS

value
DeclarationView source
LOG_STREAM_DEFAULT_FILTERSts
export declare const LOG_STREAM_DEFAULT_FILTERS: true;

LOG_STREAM_DEFAULT_INTERVAL_MS

value
DeclarationView source
LOG_STREAM_DEFAULT_INTERVAL_MSts
export declare const LOG_STREAM_DEFAULT_INTERVAL_MS: 1900;

LOG_STREAM_DEFAULT_MAX_LINES

value
DeclarationView source
LOG_STREAM_DEFAULT_MAX_LINESts
export declare const LOG_STREAM_DEFAULT_MAX_LINES: 60;

LOG_STREAM_DEFAULT_PAUSED

value
DeclarationView source
LOG_STREAM_DEFAULT_PAUSEDts
export declare const LOG_STREAM_DEFAULT_PAUSED: false;

LOG_STREAM_DEFAULT_PREFILL

value
DeclarationView source
LOG_STREAM_DEFAULT_PREFILLts
export declare const LOG_STREAM_DEFAULT_PREFILL: 8;

LOG_STREAM_LEVELS

value
DeclarationView source
LOG_STREAM_LEVELSts
export declare const LOG_STREAM_LEVELS: readonly ["INFO", "WARN", "ERR", "OK", "DBG"];

LOG_STREAM_TICK_KEY

value
DeclarationView source
LOG_STREAM_TICK_KEYts
export declare const LOG_STREAM_TICK_KEY: "log-stream.tick";

logStreamAnatomy

value
DeclarationView source
logStreamAnatomyts
export declare const logStreamAnatomy: {
  readonly scope: "log-stream";
  readonly parts: readonly ["root", "bar", "dots", "title", "filters", "filter", "body", "line", "cursor"];
};
Name
Kind
Type
Requirement
parts
property
readonly ["root", "bar", "dots", "title", "filters", "filter", "body", "line", "cursor"]
required
scope
property
"log-stream"
required
Name
parts
Kind
property
Type
readonly ["root", "bar", "dots", "title", "filters", "filter", "body", "line", "cursor"]
Requirement
required
Name
scope
Kind
property
Type
"log-stream"
Requirement
required

LogStreamApi

interface
DeclarationView source
LogStreamApits
interface LogStreamApi {
  rootProps(): PartProps;
  barProps(): PartProps;
  dotsProps(): PartProps;
  titleProps(): PartProps;
  filtersProps(): PartProps;
  filterProps(level: LogStreamLevel): PartProps;
  bodyProps(): PartProps;
  lineProps(index: number): PartProps;
  cursorProps(): PartProps;
  pause(): void;
  resume(): void;
  readonly paused: boolean;
  readonly lines: readonly LogStreamLine[];
  readonly visible: readonly LogStreamLine[];
  readonly filters: LogStreamFilterMap;
  readonly filtersEnabled: boolean;
  readonly levels: readonly LogStreamLevel[];
}
Name
Kind
Type
Requirement
barProps
method
() => PartProps
required
bodyProps
method
() => PartProps
required
cursorProps
method
() => PartProps
required
dotsProps
method
() => PartProps
required
filterProps
method
(level: LogStreamLevel) => PartProps
required
filters
property
LogStreamFilterMap
required
filtersEnabled
property
boolean
required
filtersProps
method
() => PartProps
required
levels
property
readonly LogStreamLevel[]
required
lineProps
method
(index: number) => PartProps
required
lines
property
readonly LogStreamLine[]
required
pause
method
() => void
required
paused
property
boolean
required
resume
method
() => void
required
Name
barProps
Kind
method
Type
() => PartProps
Requirement
required
Name
bodyProps
Kind
method
Type
() => PartProps
Requirement
required
Name
cursorProps
Kind
method
Type
() => PartProps
Requirement
required
Name
dotsProps
Kind
method
Type
() => PartProps
Requirement
required
Name
filterProps
Kind
method
Type
(level: LogStreamLevel) => PartProps
Requirement
required
Name
filters
Kind
property
Type
LogStreamFilterMap
Requirement
required
Name
filtersEnabled
Kind
property
Type
boolean
Requirement
required
Name
filtersProps
Kind
method
Type
() => PartProps
Requirement
required
Name
levels
Kind
property
Type
readonly LogStreamLevel[]
Requirement
required
Name
lineProps
Kind
method
Type
(index: number) => PartProps
Requirement
required
Name
lines
Kind
property
Type
readonly LogStreamLine[]
Requirement
required
Name
pause
Kind
method
Type
() => void
Requirement
required
Name
paused
Kind
property
Type
boolean
Requirement
required
Name
resume
Kind
method
Type
() => void
Requirement
required
Name
rootProps
Kind
method
Type
() => PartProps
Requirement
required
Name
titleProps
Kind
method
Type
() => PartProps
Requirement
required
Name
visible
Kind
property
Type
readonly LogStreamLine[]
Requirement
required

LogStreamCommand

type
DeclarationView source
LogStreamCommandts
type LogStreamCommand = (CommandObject & {
  readonly type: "SCROLL_TO_END";
}) | (CommandObject & {
  readonly type: "PAUSED_CHANGE_REQUEST";
  readonly paused: boolean;
}) | ScheduleCommand<LogStreamEvent> | CancelCommand;

LogStreamConnectOptions

interface
DeclarationView source
LogStreamConnectOptionsts
interface LogStreamConnectOptions {
  readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional

LogStreamContext

type
DeclarationView source
LogStreamContextts
type LogStreamContext = {
  readonly mode: BindingMode;
  readonly seeded: boolean;
  readonly lines: readonly LogStreamLine[];
  readonly nextIndex: number;
  readonly filters: LogStreamFilterMap;
};
Name
Kind
Type
Requirement
filters
property
LogStreamFilterMap
required
lines
property
readonly LogStreamLine[]
required
mode
property
BindingMode
required
nextIndex
property
number
required
seeded
property
boolean
required
Name
filters
Kind
property
Type
LogStreamFilterMap
Requirement
required
Name
lines
Kind
property
Type
readonly LogStreamLine[]
Requirement
required
Name
mode
Kind
property
Type
BindingMode
Requirement
required
Name
nextIndex
Kind
property
Type
number
Requirement
required
Name
seeded
Kind
property
Type
boolean
Requirement
required

LogStreamEntry

type
DeclarationView source
LogStreamEntryts
type LogStreamEntry = {
  readonly level: LogStreamLevel;
  readonly message: string;
  readonly ts?: string;
};
Name
Kind
Type
Requirement
level
property
LogStreamLevel
required
message
property
string
required
ts
property
string
optional
Name
level
Kind
property
Type
LogStreamLevel
Requirement
required
Name
message
Kind
property
Type
string
Requirement
required
Name
ts
Kind
property
Type
string
Requirement
optional

LogStreamEvent

type
DeclarationView source
LogStreamEventts
type LogStreamEvent = {
  readonly type: "START";
  readonly stamps: readonly string[];
} | {
  readonly type: "TICK";
  readonly stamp: string;
} | {
  readonly type: "TICK_DUE";
} | {
  readonly type: "PAUSE";
} | {
  readonly type: "RESUME";
} | {
  readonly type: "FILTER_TOGGLE";
  readonly level: LogStreamLevel;
};

LogStreamFilterMap

type
DeclarationView source
LogStreamFilterMapts
type LogStreamFilterMap = { readonly [K in LogStreamLevel]: boolean; };

LogStreamInput

type
DeclarationView source
LogStreamInputts
type LogStreamInput = {
  readonly source?: readonly LogStreamEntry[];
  readonly intervalMs?: number;
  readonly prefill?: number;
  readonly maxLines?: number;
  /** Chip UI enabled. When false, FILTER_TOGGLE is a no-op. */
  readonly filters?: boolean;
  /** S12 paused binding. Defined → controlled; omitted → uncontrolled false. */
  readonly paused?: boolean;
};
Name
Kind
Type
Requirement
Description
filters
property
boolean
optional
Chip UI enabled. When false, FILTER_TOGGLE is a no-op.
intervalMs
property
number
optional
—
maxLines
property
number
optional
—
paused
property
boolean
optional
S12 paused binding. Defined → controlled; omitted → uncontrolled false.
prefill
property
number
optional
—
source
property
readonly LogStreamEntry[]
optional
—
Name
filters
Kind
property
Type
boolean
Requirement
optional
Description
Chip UI enabled. When false, FILTER_TOGGLE is a no-op.
Name
intervalMs
Kind
property
Type
number
Requirement
optional
Description
—
Name
maxLines
Kind
property
Type
number
Requirement
optional
Description
—
Name
paused
Kind
property
Type
boolean
Requirement
optional
Description
S12 paused binding. Defined → controlled; omitted → uncontrolled false.
Name
prefill
Kind
property
Type
number
Requirement
optional
Description
—
Name
source
Kind
property
Type
readonly LogStreamEntry[]
Requirement
optional
Description
—

LogStreamLevel

type
DeclarationView source
LogStreamLevelts
type LogStreamLevel = (typeof LOG_STREAM_LEVELS)[number];

LogStreamLine

type
DeclarationView source
LogStreamLinets
type LogStreamLine = {
  readonly level: LogStreamLevel;
  readonly message: string;
  readonly ts: string;
};
Name
Kind
Type
Requirement
level
property
LogStreamLevel
required
message
property
string
required
ts
property
string
required
Name
level
Kind
property
Type
LogStreamLevel
Requirement
required
Name
message
Kind
property
Type
string
Requirement
required
Name
ts
Kind
property
Type
string
Requirement
required

logStreamMachine

value
DeclarationView source
logStreamMachinets
export declare const logStreamMachine: LogStreamMachine;

LogStreamMount

interface
DeclarationView source
LogStreamMountts
interface LogStreamMount {
  readonly service: LogStreamService;
  readonly connector: LogStreamApi;
  readonly root: HTMLElement;
  readonly body: HTMLElement;
  destroy(): void;
}
Name
Kind
Type
Requirement
body
property
HTMLElement
required
connector
property
LogStreamApi
required
destroy
method
() => void
required
root
property
HTMLElement
required
service
property
LogStreamService
required
Name
body
Kind
property
Type
HTMLElement
Requirement
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
destroy
Kind
method
Type
() => void
Requirement
required
Name
root
Kind
property
Type
HTMLElement
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required

LogStreamPart

type
DeclarationView source
LogStreamPartts
type LogStreamPart = (typeof logStreamAnatomy.parts)[number];

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
interface LogStreamPausedChangeDetail {
  readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

logStreamSelectors

value
DeclarationView source
logStreamSelectorsts
export declare const logStreamSelectors: {
  paused: (snapshot: LogStreamSnapshot) => boolean;
  running: (snapshot: LogStreamSnapshot) => boolean;
  lines: (snapshot: LogStreamSnapshot) => readonly LogStreamLine[];
  nextIndex: (snapshot: LogStreamSnapshot) => number;
  filters: (snapshot: LogStreamSnapshot) => LogStreamFilterMap;
  visible: (snapshot: LogStreamSnapshot, filtersEnabled?: boolean) => LogStreamLine[];
  mode: (snapshot: LogStreamSnapshot) => BindingMode;
};
Name
Kind
Type
Requirement
filters
property
(snapshot: LogStreamSnapshot) => LogStreamFilterMap
required
lines
property
(snapshot: LogStreamSnapshot) => readonly LogStreamLine[]
required
mode
property
(snapshot: LogStreamSnapshot) => BindingMode
required
nextIndex
property
(snapshot: LogStreamSnapshot) => number
required
paused
property
(snapshot: LogStreamSnapshot) => boolean
required
running
property
(snapshot: LogStreamSnapshot) => boolean
required
visible
property
(snapshot: LogStreamSnapshot, filtersEnabled?: boolean) => LogStreamLine[]
required
Name
filters
Kind
property
Type
(snapshot: LogStreamSnapshot) => LogStreamFilterMap
Requirement
required
Name
lines
Kind
property
Type
(snapshot: LogStreamSnapshot) => readonly LogStreamLine[]
Requirement
required
Name
mode
Kind
property
Type
(snapshot: LogStreamSnapshot) => BindingMode
Requirement
required
Name
nextIndex
Kind
property
Type
(snapshot: LogStreamSnapshot) => number
Requirement
required
Name
paused
Kind
property
Type
(snapshot: LogStreamSnapshot) => boolean
Requirement
required
Name
running
Kind
property
Type
(snapshot: LogStreamSnapshot) => boolean
Requirement
required
Name
visible
Kind
property
Type
(snapshot: LogStreamSnapshot, filtersEnabled?: boolean) => LogStreamLine[]
Requirement
required

LogStreamService

type
DeclarationView source
LogStreamServicets
type LogStreamService = Service<LogStreamInput, LogStreamStateValue, LogStreamContext, LogStreamEvent, LogStreamCommand>;

LogStreamSnapshot

type
DeclarationView source
LogStreamSnapshotts
type LogStreamSnapshot = Snapshot<LogStreamStateValue, LogStreamContext>;

LogStreamStateValue

type
DeclarationView source
LogStreamStateValuets
type LogStreamStateValue = "running" | "paused";

mountLogStream

function
DeclarationView source
mountLogStreamts
declare function mountLogStream(container: HTMLElement, options?: MountLogStreamOptions): LogStreamMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountLogStreamOptions
optional
return
return value
LogStreamMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountLogStreamOptions
Requirement
optional
Name
return
Kind
return value
Type
LogStreamMount
Requirement
n/a

MountLogStreamOptions

interface
DeclarationView source
MountLogStreamOptionsts
interface MountLogStreamOptions extends LogStreamInput {
  readonly title?: string;
  readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
  readonly scheduler?: Scheduler;
  readonly stamp?: () => string;
  readonly renderLine?: (row: HTMLElement, line: {
    level: string;
    message: string;
    ts: string;
  }) => void;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
renderLine
property
(row: HTMLElement, line: { level: string; message: string; ts: string; }) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
title
property
string
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
renderLine
Kind
property
Type
(row: HTMLElement, line: { level: string; message: string; ts: string; }) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional
Name
title
Kind
property
Type
string
Requirement
optional

runLogStreamCommand

function
DeclarationView source
runLogStreamCommandts
declare function runLogStreamCommand(command: LogStreamCommand, scope: PartScope, options?: LogStreamConnectOptions): void;
Name
Kind
Type
Requirement
command
parameter
LogStreamCommand
required
scope
parameter
PartScope
required
options
parameter
LogStreamConnectOptions
optional
return
return value
void
n/a
Name
command
Kind
parameter
Type
LogStreamCommand
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
LogStreamConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
void
Requirement
n/a

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/log-streamts
import { Bar, Body, Cursor, Dots, Filter, Filters, Line, LogStream } from "@grassroot/ui-headless-react/log-stream"; // +2 more exports

Vue imports

@grassroot/ui-headless-vue/log-streamts
<script setup lang="ts">
import { LogStreamBar, LogStreamBody, LogStreamCursor, LogStreamDots, LogStreamFilter, LogStreamFilters, LogStreamLine, LogStreamRoot } from "@grassroot/ui-headless-vue/log-stream"; // +1 more exports
</script>

Angular imports

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

Svelte imports

@grassroot/ui-headless-svelte/log-streamts
<script lang="ts">
  import { LogStreamBar, LogStreamBody, LogStreamCursor, LogStreamDots, LogStreamFilter, LogStreamFilters, LogStreamLine, LogStreamRoot } from "@grassroot/ui-headless-svelte/log-stream"; // +1 more exports
</script>

Solid imports

@grassroot/ui-headless-solid/log-streamts
import { LogStreamBar, LogStreamBody, LogStreamCursor, LogStreamDots, LogStreamFilter, LogStreamFilters, LogStreamLine, LogStreamRoot } from "@grassroot/ui-headless-solid/log-stream"; // +1 more exports

@grassroot/ui-headless-react/log-stream

React adapter

26 exports
View source packages/ui-headless/react/src/log-stream/index.ts

Bar

value
DeclarationView source
Barts
export declare const Bar: import("react").ForwardRefExoticComponent<LogStreamBarProps & 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

Body

value
DeclarationView source
Bodyts
export declare const Body: import("react").ForwardRefExoticComponent<LogStreamBodyProps & 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

Cursor

value
DeclarationView source
Cursorts
export declare const Cursor: import("react").ForwardRefExoticComponent<LogStreamCursorProps & 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

Dots

value
DeclarationView source
Dotsts
export declare const Dots: import("react").ForwardRefExoticComponent<LogStreamDotsProps & 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

Filter

value
DeclarationView source
Filterts
export declare const Filter: import("react").ForwardRefExoticComponent<LogStreamFilterProps & 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

Filters

value
DeclarationView source
Filtersts
export declare const Filters: import("react").ForwardRefExoticComponent<LogStreamFiltersProps & 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

Line

value
DeclarationView source
Linets
export declare const Line: import("react").ForwardRefExoticComponent<LogStreamLineProps & 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

LogStream

value
DeclarationView source
LogStreamts
export declare const LogStream: {
  Root: import("react").ForwardRefExoticComponent<LogStreamRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Bar: import("react").ForwardRefExoticComponent<LogStreamBarProps & import("react").RefAttributes<HTMLDivElement>>;
  Dots: import("react").ForwardRefExoticComponent<LogStreamDotsProps & import("react").RefAttributes<HTMLDivElement>>;
  Title: import("react").ForwardRefExoticComponent<LogStreamTitleProps & import("react").RefAttributes<HTMLSpanElement>>;
  Filters: import("react").ForwardRefExoticComponent<LogStreamFiltersProps & import("react").RefAttributes<HTMLDivElement>>;
  Filter: import("react").ForwardRefExoticComponent<LogStreamFilterProps & import("react").RefAttributes<HTMLButtonElement>>;
  Body: import("react").ForwardRefExoticComponent<LogStreamBodyProps & import("react").RefAttributes<HTMLDivElement>>;
  Line: import("react").ForwardRefExoticComponent<LogStreamLineProps & import("react").RefAttributes<HTMLDivElement>>;
  Cursor: import("react").ForwardRefExoticComponent<LogStreamCursorProps & import("react").RefAttributes<HTMLDivElement>>;
};
Name
Kind
Type
Requirement
Bar
property
import("react").ForwardRefExoticComponent<LogStreamBarProps & import("react").RefAttributes<HTMLDivElement>>
required
Body
property
import("react").ForwardRefExoticComponent<LogStreamBodyProps & import("react").RefAttributes<HTMLDivElement>>
required
Cursor
property
import("react").ForwardRefExoticComponent<LogStreamCursorProps & import("react").RefAttributes<HTMLDivElement>>
required
Dots
property
import("react").ForwardRefExoticComponent<LogStreamDotsProps & import("react").RefAttributes<HTMLDivElement>>
required
Filter
property
import("react").ForwardRefExoticComponent<LogStreamFilterProps & import("react").RefAttributes<HTMLButtonElement>>
required
Filters
property
import("react").ForwardRefExoticComponent<LogStreamFiltersProps & import("react").RefAttributes<HTMLDivElement>>
required
Line
property
import("react").ForwardRefExoticComponent<LogStreamLineProps & import("react").RefAttributes<HTMLDivElement>>
required
Root
property
import("react").ForwardRefExoticComponent<LogStreamRootProps & import("react").RefAttributes<HTMLDivElement>>
required
Title
property
import("react").ForwardRefExoticComponent<LogStreamTitleProps & import("react").RefAttributes<HTMLSpanElement>>
required
Name
Bar
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamBarProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Body
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamBodyProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Cursor
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamCursorProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Dots
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamDotsProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Filter
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamFilterProps & import("react").RefAttributes<HTMLButtonElement>>
Requirement
required
Name
Filters
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamFiltersProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Line
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamLineProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Root
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamRootProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
Title
Kind
property
Type
import("react").ForwardRefExoticComponent<LogStreamTitleProps & import("react").RefAttributes<HTMLSpanElement>>
Requirement
required

LogStreamBarProps

interface
DeclarationView source
LogStreamBarPropsts
interface LogStreamBarProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

LogStreamBodyProps

interface
DeclarationView source
LogStreamBodyPropsts
interface LogStreamBodyProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

LogStreamContext

value
DeclarationView source
LogStreamContextts
export declare const LogStreamContext: import("react").Context<LogStreamContextValue | 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

LogStreamContextValue

interface
DeclarationView source
LogStreamContextValuets
interface LogStreamContextValue {
  readonly service: LogStreamService;
  readonly connector: LogStreamApi;
  readonly scope: PartScope;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required

LogStreamCursorProps

interface
DeclarationView source
LogStreamCursorPropsts
interface LogStreamCursorProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

LogStreamDotsProps

interface
DeclarationView source
LogStreamDotsPropsts
interface LogStreamDotsProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

LogStreamFilterProps

interface
DeclarationView source
LogStreamFilterPropsts
interface LogStreamFilterProps extends Omit<ComponentPropsWithoutRef<"button">, "type"> {
  readonly asChild?: boolean;
  readonly level: LogStreamLevel;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
level
property
LogStreamLevel
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
level
Kind
property
Type
LogStreamLevel
Requirement
required

LogStreamFiltersProps

interface
DeclarationView source
LogStreamFiltersPropsts
interface LogStreamFiltersProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

LogStreamLineProps

interface
DeclarationView source
LogStreamLinePropsts
interface LogStreamLineProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly index: number;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
index
property
number
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
index
Kind
property
Type
number
Requirement
required

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
interface LogStreamPausedChangeDetail {
  readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

LogStreamRootProps

interface
DeclarationView source
LogStreamRootPropsts
interface LogStreamRootProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
  readonly asChild?: boolean;
  readonly source?: LogStreamInput["source"];
  readonly intervalMs?: LogStreamInput["intervalMs"];
  readonly prefill?: LogStreamInput["prefill"];
  readonly maxLines?: LogStreamInput["maxLines"];
  readonly filters?: LogStreamInput["filters"];
  readonly paused?: LogStreamInput["paused"];
  readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
  readonly scheduler?: UseLogStreamOptions["scheduler"];
  readonly stamp?: UseLogStreamOptions["stamp"];
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
filters
property
LogStreamInput["filters"]
optional
intervalMs
property
LogStreamInput["intervalMs"]
optional
maxLines
property
LogStreamInput["maxLines"]
optional
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
paused
property
LogStreamInput["paused"]
optional
prefill
property
LogStreamInput["prefill"]
optional
scheduler
property
UseLogStreamOptions["scheduler"]
optional
source
property
LogStreamInput["source"]
optional
stamp
property
UseLogStreamOptions["stamp"]
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
filters
Kind
property
Type
LogStreamInput["filters"]
Requirement
optional
Name
intervalMs
Kind
property
Type
LogStreamInput["intervalMs"]
Requirement
optional
Name
maxLines
Kind
property
Type
LogStreamInput["maxLines"]
Requirement
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
paused
Kind
property
Type
LogStreamInput["paused"]
Requirement
optional
Name
prefill
Kind
property
Type
LogStreamInput["prefill"]
Requirement
optional
Name
scheduler
Kind
property
Type
UseLogStreamOptions["scheduler"]
Requirement
optional
Name
source
Kind
property
Type
LogStreamInput["source"]
Requirement
optional
Name
stamp
Kind
property
Type
UseLogStreamOptions["stamp"]
Requirement
optional

LogStreamTitleProps

interface
DeclarationView source
LogStreamTitlePropsts
interface LogStreamTitleProps extends ComponentPropsWithoutRef<"span"> {
  readonly asChild?: boolean;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional

Root

value
DeclarationView source
Rootts
export declare const Root: import("react").ForwardRefExoticComponent<LogStreamRootProps & 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

Title

value
DeclarationView source
Titlets
export declare const Title: import("react").ForwardRefExoticComponent<LogStreamTitleProps & import("react").RefAttributes<HTMLSpanElement>>;
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

useLogStream

function
DeclarationView source
useLogStreamts
declare function useLogStream(input?: LogStreamInput, options?: UseLogStreamOptions): UseLogStreamResult;
Name
Kind
Type
Requirement
input
parameter
LogStreamInput
optional
options
parameter
UseLogStreamOptions
optional
return
return value
UseLogStreamResult
n/a
Name
input
Kind
parameter
Type
LogStreamInput
Requirement
optional
Name
options
Kind
parameter
Type
UseLogStreamOptions
Requirement
optional
Name
return
Kind
return value
Type
UseLogStreamResult
Requirement
n/a

useLogStreamContext

function
DeclarationView source
useLogStreamContextts
declare function useLogStreamContext(partName: string): LogStreamContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
LogStreamContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
LogStreamContextValue
Requirement
n/a

UseLogStreamOptions

interface
DeclarationView source
UseLogStreamOptionsts
interface UseLogStreamOptions {
  readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
  readonly scheduler?: Scheduler;
  readonly stamp?: () => string;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional

UseLogStreamResult

interface
DeclarationView source
UseLogStreamResultts
interface UseLogStreamResult {
  readonly service: LogStreamService;
  readonly connector: LogStreamApi;
  readonly scope: PartScope;
  readonly snapshot: LogStreamSnapshot;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
snapshot
property
LogStreamSnapshot
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
snapshot
Kind
property
Type
LogStreamSnapshot
Requirement
required

@grassroot/ui-headless-vue/log-stream

Vue adapter

16 exports
View source packages/ui-headless/vue/src/log-stream/index.ts

LogStreamBar

value
DeclarationView source
LogStreamBarts
export declare const LogStreamBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

LogStreamBody

value
DeclarationView source
LogStreamBodyts
export declare const LogStreamBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

LogStreamContextKey

value
DeclarationView source
LogStreamContextKeyts
export declare const LogStreamContextKey: InjectionKey<LogStreamContextValue>;

LogStreamContextValue

interface
DeclarationView source
LogStreamContextValuets
interface LogStreamContextValue {
  readonly service: LogStreamService;
  readonly connector: LogStreamApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<LogStreamSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
snapshot
property
ShallowRef<LogStreamSnapshot>
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<LogStreamSnapshot>
Requirement
required

LogStreamCursor

value
DeclarationView source
LogStreamCursorts
export declare const LogStreamCursor: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

LogStreamDots

value
DeclarationView source
LogStreamDotsts
export declare const LogStreamDots: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

LogStreamFilter

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

LogStreamFilters

value
DeclarationView source
LogStreamFiltersts
export declare const LogStreamFilters: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

LogStreamLine

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

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
interface LogStreamPausedChangeDetail {
  readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

LogStreamRoot

value
DeclarationView source
LogStreamRootts
export declare const LogStreamRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  source: {
    type: PropType<LogStreamInput["source"]>;
    default: undefined;
  };
  intervalMs: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  prefill: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  maxLines: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  filters: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  paused: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseLogStreamOptions["scheduler"]>;
    default: undefined;
  };
  stamp: {
    type: PropType<UseLogStreamOptions["stamp"]>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  pausedChange: (_detail: LogStreamPausedChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  source: {
    type: PropType<LogStreamInput["source"]>;
    default: undefined;
  };
  intervalMs: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  prefill: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  maxLines: {
    type: PropType<number | undefined>;
    default: undefined;
  };
  filters: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  paused: {
    type: PropType<boolean | undefined>;
    default: undefined;
  };
  scheduler: {
    type: PropType<UseLogStreamOptions["scheduler"]>;
    default: undefined;
  };
  stamp: {
    type: PropType<UseLogStreamOptions["stamp"]>;
    default: undefined;
  };
}>> & Readonly<{
  onPausedChange?: ((_detail: LogStreamPausedChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  source: readonly import("@grassroot/ui-machines/log-stream").LogStreamEntry[] | undefined;
  intervalMs: number | undefined;
  prefill: number | undefined;
  maxLines: number | undefined;
  filters: boolean | undefined;
  paused: boolean | undefined;
  scheduler: import("@grassroot/statechart/scheduler").Scheduler | undefined;
  stamp: (() => string) | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

LogStreamTitle

value
DeclarationView source
LogStreamTitlets
export declare const LogStreamTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, 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>;

useLogStream

function
DeclarationView source
useLogStreamts
declare function useLogStream(input?: LogStreamInput | (() => LogStreamInput), options?: UseLogStreamOptions): UseLogStreamResult;
Name
Kind
Type
Requirement
input
parameter
LogStreamInput | (() => LogStreamInput)
optional
options
parameter
UseLogStreamOptions
optional
return
return value
UseLogStreamResult
n/a
Name
input
Kind
parameter
Type
LogStreamInput | (() => LogStreamInput)
Requirement
optional
Name
options
Kind
parameter
Type
UseLogStreamOptions
Requirement
optional
Name
return
Kind
return value
Type
UseLogStreamResult
Requirement
n/a

useLogStreamContext

function
DeclarationView source
useLogStreamContextts
declare function useLogStreamContext(partName: string): LogStreamContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
LogStreamContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
LogStreamContextValue
Requirement
n/a

UseLogStreamOptions

interface
DeclarationView source
UseLogStreamOptionsts
interface UseLogStreamOptions {
  readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
  readonly scheduler?: Scheduler;
  readonly stamp?: () => string;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional

UseLogStreamResult

interface
DeclarationView source
UseLogStreamResultts
interface UseLogStreamResult {
  readonly service: LogStreamService;
  readonly connector: LogStreamApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<LogStreamSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
snapshot
property
ShallowRef<LogStreamSnapshot>
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<LogStreamSnapshot>
Requirement
required

@grassroot/ui-headless-angular/log-stream

Angular adapter

18 exports
View source packages/ui-headless/angular/src/log-stream/index.ts

applyProps

function

Applies a connector prop bag to a persistent Angular DOM element.

DeclarationView source
applyPropsts
export declare function applyProps(el: Element, props: PartProps, listeners: Map<string, EventListener>): void;
Name
Kind
Type
Requirement
el
parameter
Element
required
props
parameter
PartProps
required
listeners
parameter
Map<string, EventListener>
required
return
return value
void
n/a
Name
el
Kind
parameter
Type
Element
Requirement
required
Name
props
Kind
parameter
Type
PartProps
Requirement
required
Name
listeners
Kind
parameter
Type
Map<string, EventListener>
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

createLogStreamStore

function
DeclarationView source
createLogStreamStorets
export declare function createLogStreamStore(initialInput?: LogStreamInput, options?: CreateLogStreamStoreOptions): LogStreamStore;
Name
Kind
Type
Requirement
initialInput
parameter
LogStreamInput
optional
options
parameter
CreateLogStreamStoreOptions
optional
return
return value
LogStreamStore
n/a
Name
initialInput
Kind
parameter
Type
LogStreamInput
Requirement
optional
Name
options
Kind
parameter
Type
CreateLogStreamStoreOptions
Requirement
optional
Name
return
Kind
return value
Type
LogStreamStore
Requirement
n/a

CreateLogStreamStoreOptions

interface
DeclarationView source
CreateLogStreamStoreOptionsts
export interface CreateLogStreamStoreOptions {
    readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
    readonly onCommit?: () => void;
    readonly scheduler?: Scheduler;
    readonly stamp?: () => string;
}
Name
Kind
Type
Requirement
onCommit
property
() => void
optional
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
Name
onCommit
Kind
property
Type
() => void
Requirement
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional

createReentrantSafeTick

function

One re-entrancy policy for every Angular store's zoneless commit nudge.

DeclarationView source
createReentrantSafeTickts
export declare function createReentrantSafeTick(appRef: ApplicationRef): () => void;
Name
Kind
Type
Requirement
appRef
parameter
ApplicationRef
required
return
return value
() => void
n/a
Name
appRef
Kind
parameter
Type
ApplicationRef
Requirement
required
Name
return
Kind
return value
Type
() => void
Requirement
n/a

GR_LOG_STREAM_DECLARATIONS

value
DeclarationView source
GR_LOG_STREAM_DECLARATIONSts
export declare const GR_LOG_STREAM_DECLARATIONS: readonly [typeof GrLogStreamRoot, typeof GrLogStreamBar, typeof GrLogStreamDots, typeof GrLogStreamTitle, typeof GrLogStreamFilters, typeof GrLogStreamFilter, typeof GrLogStreamBody, typeof GrLogStreamLine, typeof GrLogStreamCursor];

GrLogStreamBar

class
DeclarationView source
GrLogStreamBarts
export declare class GrLogStreamBar implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamBar, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamBar, "[grLogStreamBar]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamBar, "[grLogStreamBar]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamBar, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamBar, "[grLogStreamBar]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamBar, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamBody

class
DeclarationView source
GrLogStreamBodyts
export declare class GrLogStreamBody implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamBody, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamBody, "[grLogStreamBody]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamBody, "[grLogStreamBody]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamBody, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamBody, "[grLogStreamBody]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamBody, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamCursor

class
DeclarationView source
GrLogStreamCursorts
export declare class GrLogStreamCursor implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamCursor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamCursor, "[grLogStreamCursor]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamCursor, "[grLogStreamCursor]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamCursor, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamCursor, "[grLogStreamCursor]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamCursor, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamDots

class
DeclarationView source
GrLogStreamDotsts
export declare class GrLogStreamDots implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamDots, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamDots, "[grLogStreamDots]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamDots, "[grLogStreamDots]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamDots, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamDots, "[grLogStreamDots]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamDots, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamFilter

class
DeclarationView source
GrLogStreamFilterts
export declare class GrLogStreamFilter implements OnDestroy {
    readonly level: import("@angular/core").InputSignal<"INFO" | "WARN" | "ERR" | "OK" | "DBG">;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamFilter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamFilter, "[grLogStreamFilter]", never, { "level": { "alias": "level"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
level
property
import("@angular/core").InputSignal<"INFO" | "WARN" | "ERR" | "OK" | "DBG">
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamFilter, "[grLogStreamFilter]", never, { "level": { "alias": "level"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamFilter, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
level
Kind
property
Type
import("@angular/core").InputSignal<"INFO" | "WARN" | "ERR" | "OK" | "DBG">
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamFilter, "[grLogStreamFilter]", never, { "level": { "alias": "level"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamFilter, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamFilters

class
DeclarationView source
GrLogStreamFiltersts
export declare class GrLogStreamFilters implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamFilters, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamFilters, "[grLogStreamFilters]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamFilters, "[grLogStreamFilters]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamFilters, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamFilters, "[grLogStreamFilters]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamFilters, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamLine

class
DeclarationView source
GrLogStreamLinets
export declare class GrLogStreamLine implements OnDestroy {
    readonly index: import("@angular/core").InputSignal<number>;
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    private registered;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamLine, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamLine, "[grLogStreamLine]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
index
property
import("@angular/core").InputSignal<number>
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamLine, "[grLogStreamLine]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamLine, never>
required
registered
property
any
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
index
Kind
property
Type
import("@angular/core").InputSignal<number>
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamLine, "[grLogStreamLine]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamLine, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrLogStreamRoot

class
DeclarationView source
GrLogStreamRootts
export declare class GrLogStreamRoot implements OnInit, OnDestroy {
    readonly source: import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/log-stream").LogStreamEntry[] | undefined>;
    readonly intervalMs: import("@angular/core").InputSignal<number | undefined>;
    readonly prefill: import("@angular/core").InputSignal<number | undefined>;
    readonly maxLines: import("@angular/core").InputSignal<number | undefined>;
    readonly filters: import("@angular/core").InputSignal<boolean | undefined>;
    readonly paused: import("@angular/core").InputSignal<boolean | undefined>;
    readonly pausedChange: import("@angular/core").OutputEmitterRef<LogStreamPausedChangeDetail>;
    private readonly elementRef;
    private readonly listeners;
    private lastSynced;
    readonly store: LogStreamStore;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    private readInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrLogStreamRoot, "gr-log-stream-root", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "prefill": { "alias": "prefill"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "paused": { "alias": "paused"; "required": false; "isSignal": true; }; }, { "pausedChange": "pausedChange"; }, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
elementRef
property
any
required
filters
property
import("@angular/core").InputSignal<boolean | undefined>
required
intervalMs
property
import("@angular/core").InputSignal<number | undefined>
required
lastSynced
property
any
required
listeners
property
any
required
maxLines
property
import("@angular/core").InputSignal<number | undefined>
required
ngOnDestroy
method
() => void
required
ngOnInit
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrLogStreamRoot, "gr-log-stream-root", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "prefill": { "alias": "prefill"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "paused": { "alias": "paused"; "required": false; "isSignal": true; }; }, { "pausedChange": "pausedChange"; }, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamRoot, never>
required
paused
property
import("@angular/core").InputSignal<boolean | undefined>
required
pausedChange
property
import("@angular/core").OutputEmitterRef<LogStreamPausedChangeDetail>
required
prefill
property
import("@angular/core").InputSignal<number | undefined>
required
readInput
property
any
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
filters
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
intervalMs
Kind
property
Type
import("@angular/core").InputSignal<number | undefined>
Requirement
required
Name
lastSynced
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
maxLines
Kind
property
Type
import("@angular/core").InputSignal<number | undefined>
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ngOnInit
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrLogStreamRoot, "gr-log-stream-root", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "prefill": { "alias": "prefill"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "paused": { "alias": "paused"; "required": false; "isSignal": true; }; }, { "pausedChange": "pausedChange"; }, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamRoot, never>
Requirement
required
Name
paused
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
pausedChange
Kind
property
Type
import("@angular/core").OutputEmitterRef<LogStreamPausedChangeDetail>
Requirement
required
Name
prefill
Kind
property
Type
import("@angular/core").InputSignal<number | undefined>
Requirement
required
Name
readInput
Kind
property
Type
any
Requirement
required
Name
source
Kind
property
Type
import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/log-stream").LogStreamEntry[] | undefined>
Requirement
required
Name
store
Kind
property
Type
LogStreamStore
Requirement
required

GrLogStreamTitle

class
DeclarationView source
GrLogStreamTitlets
export declare class GrLogStreamTitle implements OnDestroy {
    private readonly store;
    private readonly elementRef;
    private readonly listeners;
    private readonly consumerProps;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrLogStreamTitle, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrLogStreamTitle, "[grLogStreamTitle]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumerProps
property
any
required
elementRef
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrLogStreamTitle, "[grLogStreamTitle]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrLogStreamTitle, never>
required
store
property
any
required
Name
consumerProps
Kind
property
Type
any
Requirement
required
Name
elementRef
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrLogStreamTitle, "[grLogStreamTitle]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrLogStreamTitle, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

LOG_STREAM_STORE

value
DeclarationView source
LOG_STREAM_STOREts
export declare const LOG_STREAM_STORE: InjectionToken<LogStreamStore>;

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
export interface LogStreamPausedChangeDetail {
    readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

LogStreamStore

interface
DeclarationView source
LogStreamStorets
export interface LogStreamStore {
    readonly service: LogStreamService;
    readonly connector: LogStreamApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: LogStreamInput): void;
    bindPausedChange(handler: (detail: import("./use-log-stream.js").LogStreamPausedChangeDetail) => void): void;
}
Name
Kind
Type
Requirement
bindPausedChange
method
(handler: (detail: import("./use-log-stream.js").LogStreamPausedChangeDetail) => void) => void
required
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
start
method
() => void
required
stop
method
() => void
required
sync
method
(input: LogStreamInput) => void
required
version
property
WritableSignal<number>
required
Name
bindPausedChange
Kind
method
Type
(handler: (detail: import("./use-log-stream.js").LogStreamPausedChangeDetail) => void) => void
Requirement
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
start
Kind
method
Type
() => void
Requirement
required
Name
stop
Kind
method
Type
() => void
Requirement
required
Name
sync
Kind
method
Type
(input: LogStreamInput) => void
Requirement
required
Name
version
Kind
property
Type
WritableSignal<number>
Requirement
required

provideLogStreamStore

function
DeclarationView source
provideLogStreamStorets
export declare function provideLogStreamStore(): 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/log-stream

Svelte adapter

17 exports
View source packages/ui-headless/svelte/src/log-stream/index.ts

createLogStream

function
DeclarationView source
createLogStreamts
export declare function createLogStream(inputGetter?: () => LogStreamInput, options?: UseLogStreamOptions): UseLogStreamResult;
Name
Kind
Type
Requirement
inputGetter
parameter
() => LogStreamInput
optional
options
parameter
UseLogStreamOptions
optional
return
return value
UseLogStreamResult
n/a
Name
inputGetter
Kind
parameter
Type
() => LogStreamInput
Requirement
optional
Name
options
Kind
parameter
Type
UseLogStreamOptions
Requirement
optional
Name
return
Kind
return value
Type
UseLogStreamResult
Requirement
n/a

LogStreamBar

value
DeclarationView source
LogStreamBarts
export declare const LogStreamBar: 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

LogStreamBody

value
DeclarationView source
LogStreamBodyts
export declare const LogStreamBody: 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

LogStreamContextValue

interface
DeclarationView source
LogStreamContextValuets
export interface LogStreamContextValue {
    readonly service: LogStreamService;
    readonly connector: LogStreamApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
version
property
() => number
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

LogStreamCursor

value
DeclarationView source
LogStreamCursorts
export declare const LogStreamCursor: 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

LogStreamDots

value
DeclarationView source
LogStreamDotsts
export declare const LogStreamDots: 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

LogStreamFilter

value
DeclarationView source
LogStreamFilterts
export declare const LogStreamFilter: 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

LogStreamFilters

value
DeclarationView source
LogStreamFiltersts
export declare const LogStreamFilters: 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

LogStreamLine

value
DeclarationView source
LogStreamLinets
export declare const LogStreamLine: 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

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
export interface LogStreamPausedChangeDetail {
    readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

LogStreamRoot

value
DeclarationView source
LogStreamRootts
export declare const LogStreamRoot: 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

LogStreamTitle

value
DeclarationView source
LogStreamTitlets
export declare const LogStreamTitle: 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

splitProps

function

Split the core prop bag, then apply Svelte-specific style/event handling.

DeclarationView source
splitPropsts
export declare function splitProps(props: PartProps): SplitProps;
Name
Kind
Type
Requirement
props
parameter
PartProps
required
return
return value
SplitProps
n/a
Name
props
Kind
parameter
Type
PartProps
Requirement
required
Name
return
Kind
return value
Type
SplitProps
Requirement
n/a

useLogStreamContext

function
DeclarationView source
useLogStreamContextts
export declare function useLogStreamContext(partName: string): LogStreamContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
LogStreamContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
LogStreamContextValue
Requirement
n/a

UseLogStreamOptions

interface
DeclarationView source
UseLogStreamOptionsts
export interface UseLogStreamOptions {
    readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
    readonly scheduler?: Scheduler;
    readonly stamp?: () => string;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional

UseLogStreamResult

interface
DeclarationView source
UseLogStreamResultts
export interface UseLogStreamResult {
    readonly service: LogStreamService;
    readonly connector: LogStreamApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
version
property
() => number
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

wireEvents

function
DeclarationView source
wireEventsts
export declare function wireEvents(node: Element, params: {
    events: Record<string, EventListener>;
    ref?: (node: Element | null) => void;
}): {
    update(next: typeof params): void;
    destroy(): void;
};
Name
Kind
Type
Requirement
node
parameter
Element
required
params
parameter
{ events: Record<string, EventListener>; ref?: (node: Element | null) => void; }
required
return
return value
{ update(next: typeof params): void; destroy(): void; }
n/a
Name
node
Kind
parameter
Type
Element
Requirement
required
Name
params
Kind
parameter
Type
{ events: Record<string, EventListener>; ref?: (node: Element | null) => void; }
Requirement
required
Name
return
Kind
return value
Type
{ update(next: typeof params): void; destroy(): void; }
Requirement
n/a

@grassroot/ui-headless-solid/log-stream

Solid adapter

25 exports
View source packages/ui-headless/solid/src/log-stream/index.ts

LogStreamBar

function
DeclarationView source
LogStreamBarts
export declare function LogStreamBar(props: LogStreamBarProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamBarProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamBarProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamBarProps

interface
DeclarationView source
LogStreamBarPropsts
export interface LogStreamBarProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

LogStreamBody

function
DeclarationView source
LogStreamBodyts
export declare function LogStreamBody(props: LogStreamBodyProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamBodyProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamBodyProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamBodyProps

interface
DeclarationView source
LogStreamBodyPropsts
export interface LogStreamBodyProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

LogStreamContext

value
DeclarationView source
LogStreamContextts
export declare const LogStreamContext: import("solid-js").Context<LogStreamContextValue | undefined>;

LogStreamContextValue

interface
DeclarationView source
LogStreamContextValuets
export interface LogStreamContextValue {
    readonly service: LogStreamService;
    readonly connector: LogStreamApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<LogStreamSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
snapshot
property
Accessor<LogStreamSnapshot>
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<LogStreamSnapshot>
Requirement
required

LogStreamCursor

function
DeclarationView source
LogStreamCursorts
export declare function LogStreamCursor(props: LogStreamCursorProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamCursorProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamCursorProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamCursorProps

interface
DeclarationView source
LogStreamCursorPropsts
export interface LogStreamCursorProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

LogStreamDots

function
DeclarationView source
LogStreamDotsts
export declare function LogStreamDots(props: LogStreamDotsProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamDotsProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamDotsProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamDotsProps

interface
DeclarationView source
LogStreamDotsPropsts
export interface LogStreamDotsProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

LogStreamFilter

function
DeclarationView source
LogStreamFilterts
export declare function LogStreamFilter(props: LogStreamFilterProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamFilterProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamFilterProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamFilterProps

interface
DeclarationView source
LogStreamFilterPropsts
export interface LogStreamFilterProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
    readonly as?: AsProp;
    readonly level: LogStreamLevel;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
level
property
LogStreamLevel
required
Name
as
Kind
property
Type
AsProp
Requirement
optional
Name
level
Kind
property
Type
LogStreamLevel
Requirement
required

LogStreamFilters

function
DeclarationView source
LogStreamFiltersts
export declare function LogStreamFilters(props: LogStreamFiltersProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamFiltersProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamFiltersProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamFiltersProps

interface
DeclarationView source
LogStreamFiltersPropsts
export interface LogStreamFiltersProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

LogStreamLine

function
DeclarationView source
LogStreamLinets
export declare function LogStreamLine(props: LogStreamLineProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamLineProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamLineProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamLineProps

interface
DeclarationView source
LogStreamLinePropsts
export interface LogStreamLineProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
    readonly index: number;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
index
property
number
required
Name
as
Kind
property
Type
AsProp
Requirement
optional
Name
index
Kind
property
Type
number
Requirement
required

LogStreamPausedChangeDetail

interface
DeclarationView source
LogStreamPausedChangeDetailts
export interface LogStreamPausedChangeDetail {
    readonly paused: boolean;
}
Name
Kind
Type
Requirement
paused
property
boolean
required
Name
paused
Kind
property
Type
boolean
Requirement
required

LogStreamRoot

function
DeclarationView source
LogStreamRootts
export declare function LogStreamRoot(props: LogStreamRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamRootProps

interface
DeclarationView source
LogStreamRootPropsts
export interface LogStreamRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange"> {
    readonly as?: AsProp;
    readonly source?: LogStreamInput["source"];
    readonly intervalMs?: LogStreamInput["intervalMs"];
    readonly prefill?: LogStreamInput["prefill"];
    readonly maxLines?: LogStreamInput["maxLines"];
    readonly filters?: LogStreamInput["filters"];
    readonly paused?: LogStreamInput["paused"];
    readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
    readonly scheduler?: UseLogStreamOptions["scheduler"];
    readonly stamp?: UseLogStreamOptions["stamp"];
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
filters
property
LogStreamInput["filters"]
optional
intervalMs
property
LogStreamInput["intervalMs"]
optional
maxLines
property
LogStreamInput["maxLines"]
optional
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
paused
property
LogStreamInput["paused"]
optional
prefill
property
LogStreamInput["prefill"]
optional
scheduler
property
UseLogStreamOptions["scheduler"]
optional
source
property
LogStreamInput["source"]
optional
stamp
property
UseLogStreamOptions["stamp"]
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional
Name
filters
Kind
property
Type
LogStreamInput["filters"]
Requirement
optional
Name
intervalMs
Kind
property
Type
LogStreamInput["intervalMs"]
Requirement
optional
Name
maxLines
Kind
property
Type
LogStreamInput["maxLines"]
Requirement
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
paused
Kind
property
Type
LogStreamInput["paused"]
Requirement
optional
Name
prefill
Kind
property
Type
LogStreamInput["prefill"]
Requirement
optional
Name
scheduler
Kind
property
Type
UseLogStreamOptions["scheduler"]
Requirement
optional
Name
source
Kind
property
Type
LogStreamInput["source"]
Requirement
optional
Name
stamp
Kind
property
Type
UseLogStreamOptions["stamp"]
Requirement
optional

LogStreamTitle

function
DeclarationView source
LogStreamTitlets
export declare function LogStreamTitle(props: LogStreamTitleProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
LogStreamTitleProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
LogStreamTitleProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

LogStreamTitleProps

interface
DeclarationView source
LogStreamTitlePropsts
export interface LogStreamTitleProps extends JSX.HTMLAttributes<HTMLSpanElement> {
    readonly as?: AsProp;
}
Name
Kind
Type
Requirement
as
property
AsProp
optional
Name
as
Kind
property
Type
AsProp
Requirement
optional

useLogStream

function
DeclarationView source
useLogStreamts
export declare function useLogStream(input: Accessor<LogStreamInput>, options?: UseLogStreamOptions): UseLogStreamResult;
Name
Kind
Type
Requirement
input
parameter
Accessor<LogStreamInput>
required
options
parameter
UseLogStreamOptions
optional
return
return value
UseLogStreamResult
n/a
Name
input
Kind
parameter
Type
Accessor<LogStreamInput>
Requirement
required
Name
options
Kind
parameter
Type
UseLogStreamOptions
Requirement
optional
Name
return
Kind
return value
Type
UseLogStreamResult
Requirement
n/a

useLogStreamContext

function
DeclarationView source
useLogStreamContextts
export declare function useLogStreamContext(partName: string): LogStreamContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
LogStreamContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
LogStreamContextValue
Requirement
n/a

UseLogStreamOptions

interface
DeclarationView source
UseLogStreamOptionsts
export interface UseLogStreamOptions {
    readonly onPausedChange?: (detail: LogStreamPausedChangeDetail) => void;
    readonly scheduler?: Scheduler;
    readonly stamp?: () => string;
}
Name
Kind
Type
Requirement
onPausedChange
property
(detail: LogStreamPausedChangeDetail) => void
optional
scheduler
property
Scheduler
optional
stamp
property
() => string
optional
Name
onPausedChange
Kind
property
Type
(detail: LogStreamPausedChangeDetail) => void
Requirement
optional
Name
scheduler
Kind
property
Type
Scheduler
Requirement
optional
Name
stamp
Kind
property
Type
() => string
Requirement
optional

UseLogStreamResult

interface
DeclarationView source
UseLogStreamResultts
export interface UseLogStreamResult {
    readonly service: LogStreamService;
    readonly connector: LogStreamApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<LogStreamSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
LogStreamApi
required
scope
property
PartScope
required
service
property
LogStreamService
required
snapshot
property
Accessor<LogStreamSnapshot>
required
Name
connector
Kind
property
Type
LogStreamApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
LogStreamService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<LogStreamSnapshot>
Requirement
required