Options
All
  • Public
  • Public/Protected
  • All
Menu

Javascript Loop Development Kit

Index

Modules

Namespaces

Enumerations

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

Autocomplete

Autocomplete: SelectComponent<Autocomplete> & { freeSolo?: undefined | false | true; label?: undefined | string; loading?: undefined | false | true; multiple?: undefined | false | true; onChange?: WhisperHandlerWithParam<string>; onSelect: WhisperHandlerWithParam<string[]>; options?: AutocompleteOption[]; tooltip?: undefined | string; value?: undefined | string }

AutocompleteOption

AutocompleteOption: { label: string; value: string }

Type declaration

  • label: string
  • value: string

AutocompleteProps

AutocompleteProps: ComponentProps<Whisper.Autocomplete>

Box

Box: WhisperComponent<Box> & { alignItems?: AlignItems; children: Array<BoxChildComponent>; customHeight?: CustomHeight; direction: Direction; justifyContent: JustifyContent; onClick?: WhisperHandler }

BoxChildComponent

BoxChildComponent: ChildComponents | DeprecatedBox

BoxProps

BoxProps: ComponentPropsWithChildren<Whisper.Box>

Breadcrumbs

Breadcrumbs: WhisperComponent<Breadcrumbs> & { links: Link[] }

BreadcumbsProps

BreadcumbsProps: ComponentProps<Whisper.Breadcrumbs>

Button

Button: WhisperComponent<Button> & { buttonStyle?: ButtonStyle; disabled?: undefined | false | true; label?: undefined | string; onClick: WhisperHandler; size?: ButtonSize; tooltip?: undefined | string }

ButtonProps

ButtonProps: ComponentProps<Whisper.Button>

label

label: string

onMount

onMount: () => void

Type declaration

    • (): void
    • Returns void

Optional onRender

onRender: undefined | ((n: number) => void)

Optional onUnmount

onUnmount: undefined | (() => void)

CallbackError

CallbackError: (error: Error | undefined) => void

A simplified representation of a callback which take error

Type declaration

    • (error: Error | undefined): void
    • Parameters

      • error: Error | undefined

      Returns void

Checkbox

Checkbox: SelectComponent<Checkbox> & { label?: undefined | string; onChange: WhisperHandlerWithParam<boolean>; tooltip?: undefined | string; value?: undefined | false | true }

CheckboxProps

CheckboxProps: ComponentProps<Whisper.Checkbox>

ChildComponents

ChildSet

ChildSet: NewWhisper

CollapseBox

CollapseBox: WhisperComponent<CollapseBox> & { children: Array<ChildComponents>; label?: undefined | string; onClick?: WhisperHandlerWithParam<boolean>; open: boolean; openDirection?: OpenDirection }

CollapseBoxProps

CollapseBoxProps: ComponentPropsWithChildren<Whisper.CollapseBox>

Component

ComponentTypeWithWhisper

ComponentTypeWithWhisper: WhisperComponentType | "whisper"

Components

Components: Component
deprecated

Container

DateTimeInput

DateTimeInput: InputComponent<DateTimeInput, Date, string> & { dateTimeType: DateTimeType; max?: Date; min?: Date }

DateTimeInputProps

DateTimeInputProps: ComponentProps<Whisper.DateTimeInput>

DeprecatedBox

DeprecatedBox: WhisperComponent<Box> & { alignItems?: AlignItems; alignment: JustifyContent; children: Array<BoxChildComponent>; customHeight?: CustomHeight; direction: Direction; onClick?: WhisperHandler }

Divider

DividerProps

DividerProps: ComponentProps<Whisper.Divider>

DropZone

DropZone: WhisperComponent<DropZone> & { accept?: string[]; label: string; limit?: undefined | number; noun?: undefined | string; onDrop: WhisperHandlerWithParam<File[]>; tooltip?: undefined | string; validationError?: undefined | string; value?: File[] }

DropZoneProps

DropZoneProps: ComponentProps<Whisper.DropZone>

Email

Email: InputComponent<Email, string>

EmailProps

EmailProps: ComponentProps<Whisper.Email>

Field

Field: { displayName?: undefined | string; name: string; type?: FieldType }

Type declaration

  • Optional displayName?: undefined | string

    The name of the field that will be used instead of the default name of the field (if provided)

  • name: string

    The name of the field

  • Optional type?: FieldType

    The type of mapping for the field

HostConfigNoTimeout

HostConfigNoTimeout: string

HostConfigPublicInstance

HostConfigPublicInstance: string

HostConfigTimeoutHandle

HostConfigTimeoutHandle: Timeout

HostContext

HostContext: null

Icon

Icon: WhisperComponent<Icon> & { color?: Black | Grey | White | WhisperStrip; name: string; onClick?: WhisperHandler; size?: IconSize; tooltip?: undefined | string }

IconProps

IconProps: ComponentProps<Whisper.Icon>

Instance

Instance: WhisperComponent<WhisperComponentType> | { components: Instance[]; label: string; onClose: () => void; type: "whisper" }

Link

Link: WhisperComponent<Link> & { href?: undefined | string; onClick?: WhisperHandler; style?: Urgency; text: string; textAlign?: TextAlign }

LinkProps

LinkProps: ComponentProps<Whisper.Link>

ListPair

ListPair: WhisperComponent<ListPair> & { copyable: boolean; label: string; labelCopyable?: undefined | false | true; onCopy?: WhisperHandlerWithParam<string>; style: Urgency; value: string }

ListPairProps

ListPairProps: ComponentProps<Whisper.ListPair>

Mapper

Mapper<TIn, TOut>: (param: TIn) => TOut

Type parameters

  • TIn

  • TOut

Type declaration

    • (param: TIn): TOut
    • Parameters

      • param: TIn

      Returns TOut

Markdown

Markdown: WhisperComponent<Markdown> & { body: string; copyable?: MarkdownWhisperCopyMode; onCopy?: WhisperHandler; onLinkClick?: WhisperHandlerWithParam<string>; tooltip?: undefined | string }

MarkdownProps

MarkdownProps: ComponentProps<Whisper.Markdown>

Message

Message: WhisperComponent<Message> & { body?: undefined | string; copyable?: MessageWhisperCopyMode; header?: undefined | string; onCopy?: WhisperHandler; style?: Urgency | Accent | Black | Grey; textAlign?: TextAlign; tooltip?: undefined | string }

MessageProps

MessageProps: ComponentProps<Whisper.Message>

NumberInput

NumberInput: InputComponent<Number, number> & { max?: undefined | number; min?: undefined | number; step?: undefined | number }

NumberInputProps

NumberInputProps: ComponentProps<Whisper.NumberInput>

Password

Password: InputComponent<Password, string>

PasswordProps

PasswordProps: ComponentProps<Whisper.Password>

Progress

Progress: WhisperComponent<Progress> & { determinate?: undefined | number; shape?: ProgressShape; size?: StyleSize }

ProgressProps

ProgressProps: ComponentProps<Whisper.Progress>

Props

Props: Record<string, any>

RadioGroup

RadioGroup: SelectComponent<RadioGroup> & { onSelect: WhisperHandlerWithParam<number>; options: string[]; selected?: undefined | number }

RadioGroupProps

RadioGroupProps: ComponentProps<Whisper.RadioGroup>

ReconcilerInstance

ReconcilerInstance: Reconciler.Reconciler<WhisperRenderingInterface, Instance, Markdown, unknown, Instance>

RichTextEditor

RichTextEditor: WhisperComponent<RichTextEditor> & { onBlur?: undefined | ((error: Error | undefined) => void); onChange: WhisperHandlerWithParam<string>; onFocus?: undefined | ((error: Error | undefined) => void); tooltip?: undefined | string; validationError?: undefined | string }

RichTextEditorProps

RichTextEditorProps: ComponentProps<Whisper.RichTextEditor>

SectionTitle

SectionTitle: WhisperComponent<SectionTitle> & { backgroundStyle?: Grey | White; body: string; textAlign?: TextAlign }

SectionTitleProps

SectionTitleProps: ComponentProps<Whisper.SectionTitle>

Select

Select: SelectComponent<Select> & { excludeDefaultOption?: undefined | false | true; label?: undefined | string; onSelect: WhisperHandlerWithParam<number>; options: string[]; selected?: undefined | number; tooltip?: undefined | string }

SelectProps

SelectProps: ComponentProps<Whisper.Select>

StateMap

StateMap: Map<string, string | boolean | number | string[]>

Telephone

Telephone: InputComponent<Telephone, string>

TelephoneProps

TelephoneProps: ComponentProps<Whisper.Telephone>

TextInput

TextInput: InputComponent<TextInput, string>

TextInputProps

TextInputProps: ComponentProps<Whisper.TextInput>

TextInstance

TextInstance: Markdown

Type

Type: keyof HelpsComponents

Update

Update: Record<string, any>

WhisperHandler

WhisperHandler: (error: Error | undefined, whisper: Whisper) => void

Type declaration

    • (error: Error | undefined, whisper: Whisper): void
    • Parameters

      • error: Error | undefined
      • whisper: Whisper

      Returns void

WhisperHandlerWithParam

WhisperHandlerWithParam<T>: (error: Error | undefined, param: T, whisper: Whisper) => void

Type parameters

  • T

Type declaration

    • (error: Error | undefined, param: T, whisper: Whisper): void
    • Parameters

      • error: Error | undefined
      • param: T
      • whisper: Whisper

      Returns void

WhisperProps

WhisperProps: { children: ReactNode; label: string; onClose: WhisperHandler }

Type declaration

WindowAction

WindowActionBlur

WindowActionBlur: "blur"

WindowActionClosed

WindowActionClosed: "close"

WindowActionFocused

WindowActionFocused: "focus"

WindowActionMoved

WindowActionMoved: "move"

WindowActionOpened

WindowActionOpened: "open"

WindowActionResize

WindowActionResize: "resize"

WindowActionTitleChanged

WindowActionTitleChanged: "titleChange"

WriteMode

WriteMode: number

Represents file mode and permission bits

Variables

Const Alignment

Alignment: JustifyContent = JustifyContent
deprecated
  • Use JustifyContent instead.

Const _browser

_browser: Browser = browser

Const _clipboard

_clipboard: Clipboard = clipboard

Const _cursor

_cursor: Cursor = cursor

Const _document

_document: Document = document

Const _filesystem

_filesystem: Filesystem = filesystem

Const _keyboard

_keyboard: Keyboard = keyboard

Const _network

_network: Network = network

Const _process

_process: Process = process

Const _screen

_screen: Screen = screen

Const _search

_search: Search = search

Const _system

_system: System = system

Const _ui

_ui: UI = ui

Const _user

_user: User = user

Const _vault

_vault: Vault = vault

Const _whisper

_whisper: WhisperAptitude = whisper

Const _window

_window: Window = window

Const baseBabelConfig

baseBabelConfig: RuleSetRule = buildBabelConfig(false)

Const buildPath

buildPath: string = path.join(process.cwd(), 'dist')

Const ldkSettings

ldkSettings: LdkSettings = generateLdkSettings()

Const oliveHelps

oliveHelps: Aptitudes

Const optimization

optimization: undefined | Optimization = buildOptimization(true)

Const permissionsErrorMessage

permissionsErrorMessage: "Please add a "ldk" object to your package.json file with a permission property:"ldk": {"permissions": {}}See README for more information." = `Please add a "ldk" object to your package.json file with a permission property:"ldk": {"permissions": {}}See README for more information.`

Functions

activeWindow

all

assertUnreachable

  • assertUnreachable(_: never): never

buildBabelConfig

  • buildBabelConfig(cache: boolean): RuleSetRule

buildBabelPlugins

  • buildBabelPlugins(includeJsx?: boolean): babel.PluginItem[]

buildBabelPreset

  • buildBabelPreset(): babel.PluginItem[]

buildOptimization

  • buildOptimization(minimize: boolean): Configuration["optimization"]
  • Parameters

    • minimize: boolean

    Returns Configuration["optimization"]

buildWebpackConfig

  • buildWebpackConfig(buildPath: string, baseBabelConfig: RuleSetRule, optimization: Configuration["optimization"], ldkSettings: LdkSettings): Configuration
  • Parameters

    • buildPath: string
    • baseBabelConfig: RuleSetRule
    • optimization: Configuration["optimization"]
    • ldkSettings: LdkSettings

    Returns Configuration

copy

  • copy(source: string, destination: string): Promise<void>

create

createAppendFunction

createIndex

decode

  • decode(encodedValue: Uint8Array): Promise<string>

dir

  • dir(path: string): Promise<FileInfo[]>

encode

  • encode(text: string): Promise<Uint8Array>

exists

  • exists(path: string): Promise<boolean>

generateBanner

generateLdkSettings

generateMetadata

getHandlerByHelpsType

getHandlerByTagType

Const handleCaughtError

  • handleCaughtError(reject: (reason?: any) => void, error: Error): void
  • handleCaughtError(reject: (reason?: unknown) => void, error: Error | undefined | unknown, type: string): void
  • handleCaughtError(reject: (reason?: any) => void, error: Error, type: string): void
  • Parameters

    • reject: (reason?: any) => void
        • (reason?: any): void
        • Parameters

          • Optional reason: any

          Returns void

    • error: Error

    Returns void

  • Parameters

    • reject: (reason?: unknown) => void
        • (reason?: unknown): void
        • Parameters

          • Optional reason: unknown

          Returns void

    • error: Error | undefined | unknown
    • type: string

    Returns void

  • Parameters

    • reject: (reason?: any) => void
        • (reason?: any): void
        • Parameters

          • Optional reason: any

          Returns void

    • error: Error
    • type: string

    Returns void

handleListenerCallback

  • handleListenerCallback<T>(cb: (v: T) => void): Callback<T>
  • Type parameters

    • T

    Parameters

    • cb: (v: T) => void
        • (v: T): void
        • Parameters

          • v: T

          Returns void

    Returns Callback<T>

httpRequest

join

  • join(segments: string[]): Promise<string>

jwt

  • jwt(jwtConfig?: JWTConfig): Promise<string>

listen

  • listen(includeOliveHelpsEvents: boolean, callback: (clipboardText: string) => void): Promise<Cancellable>
  • Parameters

    • includeOliveHelpsEvents: boolean
    • callback: (clipboardText: string) => void
        • (clipboardText: string): void
        • Parameters

          • clipboardText: string

          Returns void

    Returns Promise<Cancellable>

listenActiveWindow

listenAll

listenCharacter

  • listenCharacter(callback: (char: string) => void): Promise<Cancellable>
  • Parameters

    • callback: (char: string) => void
        • (char: string): void
        • Parameters

          • char: string

          Returns void

    Returns Promise<Cancellable>

listenDir

listenFile

listenGlobalSearch

  • listenGlobalSearch(callback: (val: string) => void): Promise<Cancellable>
  • Parameters

    • callback: (val: string) => void
        • (val: string): void
        • Parameters

          • val: string

          Returns void

    Returns Promise<Cancellable>

listenHotkey

  • listenHotkey(hotkey: Hotkey, callback: (pressed: boolean) => void): Promise<Cancellable>
  • Parameters

    • hotkey: Hotkey
    • callback: (pressed: boolean) => void
        • (pressed: boolean): void
        • Parameters

          • pressed: boolean

          Returns void

    Returns Promise<Cancellable>

listenNavigation

listenPosition

listenSearchbar

  • listenSearchbar(callback: (val: string) => void): Promise<Cancellable>
  • Parameters

    • callback: (val: string) => void
        • (val: string): void
        • Parameters

          • val: string

          Returns void

    Returns Promise<Cancellable>

listenText

  • listenText(callback: (text: string) => void, includeOliveHelpsEvents?: boolean): Promise<Cancellable>
  • Parameters

    • callback: (text: string) => void
        • (text: string): void
        • Parameters

          • text: string

          Returns void

    • Default value includeOliveHelpsEvents: boolean = false

    Returns Promise<Cancellable>

listenTextSelection

  • listenTextSelection(callback: (value: string) => void): Promise<Cancellable>
  • Parameters

    • callback: (value: string) => void
        • (value: string): void
        • Parameters

          • value: string

          Returns void

    Returns Promise<Cancellable>

loopOpenHandler

  • loopOpenHandler(callback: () => void): Promise<Cancellable>

makeDir

  • makeDir(destination: string, writeMode: WriteMode): Promise<void>

Const mapToBinaryData

  • mapToBinaryData(message: string | Uint8Array): Array<number>
  • Parameters

    • message: string | Uint8Array

    Returns Array<number>

Const mapToDate

  • mapToDate(date: number): Date

mapToExternalWhisper

Const mapToFileEvent

mapToFileInfo

mapToFileInfoArray

Const mapToHttpRequest

Const mapToHttpResponse

Const mapToIndex

mapToInternalChildComponent

mapToInternalComponent

mapToInternalWhisper

Const mapToMessageType

  • mapToMessageType(message: string | Uint8Array): MessageType

Const mapToResponseMessage

  • mapToResponseMessage(messageType: MessageType, buffer: ArrayBuffer): string | Uint8Array

Const mapToSocket

Const mapToUint8Array

  • mapToUint8Array(data: ArrayBuffer): Uint8Array

mergeLdkSettings

move

  • move(source: string, destination: string): Promise<void>

ocr

openIndex

  • openIndex(name: string, config: Config): Promise<Index>

openTab

  • openTab(address: string): Promise<number>

openWindow

  • openWindow(address: string): Promise<number>

openWithDefaultApplication

  • openWithDefaultApplication(path: string): Promise<void>

operatingSystem

  • operatingSystem(): Promise<string>

position

promiseResolver

  • promiseResolver<T>(resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void): (error: Error | undefined, value: T) => void
  • Type parameters

    • T

    Parameters

    • resolve: (value: T | PromiseLike<T>) => void
        • (value: T | PromiseLike<T>): void
        • Parameters

          • value: T | PromiseLike<T>

          Returns void

    • reject: (reason?: any) => void
        • (reason?: any): void
        • Parameters

          • Optional reason: any

          Returns void

    Returns (error: Error | undefined, value: T) => void

      • (error: Error | undefined, value: T): void
      • Parameters

        • error: Error | undefined
        • value: T

        Returns void

promisify

  • promisify<T>(arg: Readable<T>): Promise<T>

promisifyListenable

promisifyListenableWithParam

promisifyMappedBothWithParams

  • promisifyMappedBothWithParams<TParamIn, TParamOut, TInternalOut, TExternalOut>(param: TParamIn, paramMap: Mapper<TParamIn, TParamOut>, map: Mapper<TInternalOut, TExternalOut>, arg: ReadableWithParam<TParamOut, TInternalOut>): Promise<TExternalOut>
  • Type parameters

    • TParamIn

    • TParamOut

    • TInternalOut

    • TExternalOut

    Parameters

    Returns Promise<TExternalOut>

promisifyMappedListenableWithParam

  • promisifyMappedListenableWithParam<TParam, TInternalOut, TExternalOut>(param: TParam, map: Mapper<TInternalOut, TExternalOut>, cb: (v: TExternalOut) => void, arg: ListenableWithParam<TParam, TInternalOut>): Promise<Cancellable>
  • Type parameters

    • TParam

    • TInternalOut

    • TExternalOut

    Parameters

    • param: TParam
    • map: Mapper<TInternalOut, TExternalOut>
    • cb: (v: TExternalOut) => void
        • (v: TExternalOut): void
        • Parameters

          • v: TExternalOut

          Returns void

    • arg: ListenableWithParam<TParam, TInternalOut>

    Returns Promise<Cancellable>

promisifyMappedWithParam

  • promisifyMappedWithParam<TParam, TInternalOut, TExternalOut>(param: TParam, map: Mapper<TInternalOut, TExternalOut>, arg: ReadableWithParam<TParam, TInternalOut>): Promise<TExternalOut>
  • Type parameters

    • TParam

    • TInternalOut

    • TExternalOut

    Parameters

    Returns Promise<TExternalOut>

promisifyMappedWithThreeParams

  • promisifyMappedWithThreeParams<TParam1, TParam2, TParam3, TInternalOut, TExternalOut>(param1: TParam1, param2: TParam2, param3: TParam3, map: Mapper<TInternalOut, TExternalOut>, arg: ReadableWithThreeParams<TParam1, TParam2, TParam3, TInternalOut>): Promise<TExternalOut>
  • Type parameters

    • TParam1

    • TParam2

    • TParam3

    • TInternalOut

    • TExternalOut

    Parameters

    • param1: TParam1
    • param2: TParam2
    • param3: TParam3
    • map: Mapper<TInternalOut, TExternalOut>
    • arg: ReadableWithThreeParams<TParam1, TParam2, TParam3, TInternalOut>

    Returns Promise<TExternalOut>

promisifyMappedWithTwoParams

  • promisifyMappedWithTwoParams<TParam1, TParam2, TInternalOut, TExternalOut>(param1: TParam1, param2: TParam2, map: Mapper<TInternalOut, TExternalOut>, arg: ReadableWithTwoParams<TParam1, TParam2, TInternalOut>): Promise<TExternalOut>
  • Type parameters

    • TParam1

    • TParam2

    • TInternalOut

    • TExternalOut

    Parameters

    Returns Promise<TExternalOut>

promisifyWithFourParams

  • promisifyWithFourParams<TParam1, TParam2, TParam3, TParam4, TOut>(p1: TParam1, p2: TParam2, p3: TParam3, p4: TParam4, arg: ReadableWithFourParams<TParam1, TParam2, TParam3, TParam4, TOut>): Promise<TOut>
  • Type parameters

    • TParam1

    • TParam2

    • TParam3

    • TParam4

    • TOut

    Parameters

    • p1: TParam1
    • p2: TParam2
    • p3: TParam3
    • p4: TParam4
    • arg: ReadableWithFourParams<TParam1, TParam2, TParam3, TParam4, TOut>

    Returns Promise<TOut>

promisifyWithParam

  • promisifyWithParam<TParam, TOut>(param: TParam, arg: ReadableWithParam<TParam, TOut>): Promise<TOut>

promisifyWithParamAfterCallback

promisifyWithTwoParams

  • promisifyWithTwoParams<TParam1, TParam2, TOut>(param: TParam1, param2: TParam2, arg: ReadableWithTwoParams<TParam1, TParam2, TOut>): Promise<TOut>

read

  • read(): Promise<string>

readFile

  • readFile(path: string): Promise<Uint8Array>

remove

  • remove(source: string): Promise<void>

render

renderNewWhisper

stat

Const stripBom

  • stripBom(value: Uint8Array): Uint8Array

throwForDuplicateKeys

  • throwForDuplicateKeys<T>(components: T[]): T[]
  • Type parameters

    • T: { key?: undefined | string }

    Parameters

    • components: T[]

    Returns T[]

unzip

  • unzip(zipFilePath: string, outputDirPath: string): Promise<void>

webSocketConnect

workDir

  • workDir(): Promise<string>

write

  • write(text: string): Promise<void>

writeFile

  • writeFile(__namedParameters: { data: string | Uint8Array; path: string; writeMode: number; writeOperation: WriteOperation }): Promise<void>
  • Parameters

    • __namedParameters: { data: string | Uint8Array; path: string; writeMode: number; writeOperation: WriteOperation }
      • data: string | Uint8Array
      • path: string
      • writeMode: number
      • writeOperation: WriteOperation

    Returns Promise<void>

xlsxDecode

  • xlsxDecode(data: Uint8Array): Promise<Workbook>

xlsxEncode

  • xlsxEncode(workbook: Workbook): Promise<Uint8Array>

Object literals

Const autoCompleteHandler

autoCompleteHandler: object

helpsType

helpsType: Autocomplete = WhisperComponentType.Autocomplete

whisperTagType

whisperTagType: "oh-autocomplete" = "oh-autocomplete"

Const boxHandler

boxHandler: object

appendInitialChild

appendInitialChild: (instance: Instance, child: Instance | TextInstance) => boolean = createAppendFunction('children', [WhisperComponentType.CollapseBox])

Type declaration

helpsType

helpsType: Box = WhisperComponentType.Box

whisperTagType

whisperTagType: "oh-box" = "oh-box"

Const breadcrumbsHandler

breadcrumbsHandler: object

helpsType

helpsType: Breadcrumbs = WhisperComponentType.Breadcrumbs

whisperTagType

whisperTagType: "oh-breadcrumbs" = "oh-breadcrumbs"

Const buttonHandler

buttonHandler: object

helpsType

helpsType: Button = WhisperComponentType.Button

whisperTagType

whisperTagType: "oh-button" = "oh-button"

Const checkboxHandler

checkboxHandler: object

helpsType

helpsType: Checkbox = WhisperComponentType.Checkbox

whisperTagType

whisperTagType: "oh-checkbox" = "oh-checkbox"

Const collapseBoxHandler

collapseBoxHandler: object

appendInitialChild

appendInitialChild: (instance: Instance, child: Instance | TextInstance) => boolean = createAppendFunction('children')

Type declaration

helpsType

helpsType: CollapseBox = WhisperComponentType.CollapseBox

whisperTagType

whisperTagType: "oh-collapse-box" = "oh-collapse-box"

Const config

config: object = buildWebpackConfig(buildPath,baseBabelConfig,optimization,ldkSettings,)

afterActiveInstanceBlur

afterActiveInstanceBlur: undefined = undefined

beforeActiveInstanceBlur

beforeActiveInstanceBlur: undefined = undefined

detachDeletedInstance

detachDeletedInstance: undefined = undefined

getCurrentEventPriority

getCurrentEventPriority: undefined = undefined

getInstanceFromScope

getInstanceFromScope: undefined = undefined

isPrimaryRenderer

isPrimaryRenderer: true = true

makeClientId

makeClientId: undefined = undefined

makeClientIdInDEV

makeClientIdInDEV: undefined = undefined

makeOpaqueHydratingObject

makeOpaqueHydratingObject: undefined = undefined

noTimeout

noTimeout: undefined = undefined

preparePortalMount

preparePortalMount: undefined = undefined

prepareScopeUpdate

prepareScopeUpdate: undefined = undefined

supportsHydration

supportsHydration: false = false

supportsMutation

supportsMutation: false = false

supportsPersistence

supportsPersistence: true = true

warnsIfNotActing

warnsIfNotActing: undefined = undefined

appendChildToContainerChildSet

appendInitialChild

cancelTimeout

cloneHiddenInstance

cloneHiddenTextInstance

  • cloneHiddenTextInstance(instance: Instance, text: string, internalInstanceHandle: any): TextInstance

cloneInstance

createContainerChildSet

createInstance

createTextInstance

finalizeContainerChildren

finalizeInitialChildren

getChildHostContext

getInstanceFromNode

  • getInstanceFromNode(node: any): any

getOffscreenContainerProps

  • getOffscreenContainerProps(mode: any, children: any): Props

getOffscreenContainerType

  • getOffscreenContainerType(): string

getPublicInstance

getRootHostContext

isOpaqueHydratingObject

  • isOpaqueHydratingObject(value: any): boolean

now

  • now(): number

prepareForCommit

  • prepareForCommit(containerInfo: Container): Record<string, any> | null

prepareUpdate

replaceContainerChildren

resetAfterCommit

  • resetAfterCommit(containerInfo: Container): void

scheduleTimeout

shouldSetTextContent

  • shouldSetTextContent(type: Type, props: Props): boolean

Const dateTimeHandler

dateTimeHandler: object

helpsType

helpsType: DateTimeInput = WhisperComponentType.DateTimeInput

whisperTagType

whisperTagType: "oh-datetime" = "oh-datetime"

Const dividerHandler

dividerHandler: object

helpsType

helpsType: Divider = WhisperComponentType.Divider

whisperTagType

whisperTagType: "oh-divider" = "oh-divider"

Const dropZoneHandler

dropZoneHandler: object

helpsType

helpsType: DropZone = WhisperComponentType.DropZone

whisperTagType

whisperTagType: "oh-drop-zone" = "oh-drop-zone"

Const emailHandler

emailHandler: object

helpsType

helpsType: Email = WhisperComponentType.Email

whisperTagType

whisperTagType: "oh-email" = "oh-email"

Const iconHandler

iconHandler: object

helpsType

helpsType: Icon = WhisperComponentType.Icon

whisperTagType

whisperTagType: "oh-icon" = "oh-icon"

Const keyboard

keyboard: object

listenCharacter

listenCharacter: listenCharacter

listenHotkey

listenHotkey: listenHotkey

listenText

listenText: listenText

Const linkHandler

linkHandler: object

helpsType

helpsType: Link = WhisperComponentType.Link

whisperTagType

whisperTagType: "oh-link" = "oh-link"

Const listPairHandler

listPairHandler: object

helpsType

helpsType: ListPair = WhisperComponentType.ListPair

whisperTagType

whisperTagType: "oh-list-pair" = "oh-list-pair"

Const markdownHandler

markdownHandler: object

helpsType

helpsType: Markdown = WhisperComponentType.Markdown

whisperTagType

whisperTagType: "oh-markdown" = "oh-markdown"

Const messageHandler

messageHandler: object

helpsType

helpsType: Message = WhisperComponentType.Message

whisperTagType

whisperTagType: "oh-message" = "oh-message"

Const numberHandler

numberHandler: object

helpsType

helpsType: Number = WhisperComponentType.Number

whisperTagType

whisperTagType: "oh-number" = "oh-number"

Const passwordHandler

passwordHandler: object

helpsType

helpsType: Password = WhisperComponentType.Password

whisperTagType

whisperTagType: "oh-password" = "oh-password"

Const progressHandler

progressHandler: object

helpsType

helpsType: Progress = WhisperComponentType.Progress

whisperTagType

whisperTagType: "oh-progress" = "oh-progress"

Const radioGroupHandler

radioGroupHandler: object

helpsType

helpsType: RadioGroup = WhisperComponentType.RadioGroup

whisperTagType

whisperTagType: "oh-radio-group" = "oh-radio-group"

Const richTextEditorHandler

richTextEditorHandler: object

helpsType

helpsType: RichTextEditor = WhisperComponentType.RichTextEditor

whisperTagType

whisperTagType: "oh-rich-text-editor" = "oh-rich-text-editor"

Const sectionTitleHandler

sectionTitleHandler: object

helpsType

helpsType: SectionTitle = WhisperComponentType.SectionTitle

whisperTagType

whisperTagType: "oh-section-title" = "oh-section-title"

Const selectHandler

selectHandler: object

helpsType

helpsType: Select = WhisperComponentType.Select

whisperTagType

whisperTagType: "oh-select" = "oh-select"

Const telephoneHandler

telephoneHandler: object

helpsType

helpsType: Telephone = WhisperComponentType.Telephone

whisperTagType

whisperTagType: "oh-telephone" = "oh-telephone"

Const textInputHandler

textInputHandler: object

helpsType

helpsType: TextInput = WhisperComponentType.TextInput

whisperTagType

whisperTagType: "oh-text-input" = "oh-text-input"

Const whisperHandler

whisperHandler: object

appendInitialChild

appendInitialChild: (instance: Instance, child: Instance | TextInstance) => boolean = createAppendFunction('components')

Type declaration

helpsType

helpsType: any = 'whisper' as any

whisperTagType

whisperTagType: "oh-whisper" = "oh-whisper"

Generated using TypeDoc