@cycle/dom

  • Version 22.8.0
  • Published
  • 533 kB
  • 4 dependencies
  • MIT license

Install

npm i @cycle/dom
yarn add @cycle/dom
pnpm add @cycle/dom

Overview

The standard DOM Driver for Cycle.js, based on Snabbdom

Index

Variables

variable a

const a: HyperScriptHelperFn;

    variable abbr

    const abbr: HyperScriptHelperFn;

      variable address

      const address: HyperScriptHelperFn;

        variable area

        const area: HyperScriptHelperFn;

          variable article

          const article: HyperScriptHelperFn;

            variable aside

            const aside: HyperScriptHelperFn;

              variable audio

              const audio: HyperScriptHelperFn;

                variable b

                const b: HyperScriptHelperFn;

                  variable base

                  const base: HyperScriptHelperFn;

                    variable bdi

                    const bdi: HyperScriptHelperFn;

                      variable bdo

                      const bdo: HyperScriptHelperFn;

                        variable blockquote

                        const blockquote: HyperScriptHelperFn;

                          variable body

                          const body: HyperScriptHelperFn;

                            variable br

                            const br: HyperScriptHelperFn;

                              variable button

                              const button: HyperScriptHelperFn;

                                variable canvas

                                const canvas: HyperScriptHelperFn;

                                  variable caption

                                  const caption: HyperScriptHelperFn;

                                    variable cite

                                    const cite: HyperScriptHelperFn;

                                      variable code

                                      const code: HyperScriptHelperFn;

                                        variable col

                                        const col: HyperScriptHelperFn;

                                          variable colgroup

                                          const colgroup: HyperScriptHelperFn;

                                            variable dd

                                            const dd: HyperScriptHelperFn;

                                              variable del

                                              const del: HyperScriptHelperFn;

                                                variable dfn

                                                const dfn: HyperScriptHelperFn;

                                                  variable dir

                                                  const dir: HyperScriptHelperFn;

                                                    variable div

                                                    const div: HyperScriptHelperFn;

                                                      variable dl

                                                      const dl: HyperScriptHelperFn;

                                                        variable dt

                                                        const dt: HyperScriptHelperFn;

                                                          variable em

                                                          const em: HyperScriptHelperFn;

                                                            variable embed

                                                            const embed: HyperScriptHelperFn;

                                                              variable fieldset

                                                              const fieldset: HyperScriptHelperFn;

                                                                variable figcaption

                                                                const figcaption: HyperScriptHelperFn;

                                                                  variable figure

                                                                  const figure: HyperScriptHelperFn;
                                                                    const footer: HyperScriptHelperFn;

                                                                      variable form

                                                                      const form: HyperScriptHelperFn;

                                                                        variable h1

                                                                        const h1: HyperScriptHelperFn;

                                                                          variable h2

                                                                          const h2: HyperScriptHelperFn;

                                                                            variable h3

                                                                            const h3: HyperScriptHelperFn;

                                                                              variable h4

                                                                              const h4: HyperScriptHelperFn;

                                                                                variable h5

                                                                                const h5: HyperScriptHelperFn;

                                                                                  variable h6

                                                                                  const h6: HyperScriptHelperFn;
                                                                                    const head: HyperScriptHelperFn;
                                                                                      const header: HyperScriptHelperFn;

                                                                                        variable hgroup

                                                                                        const hgroup: HyperScriptHelperFn;

                                                                                          variable hr

                                                                                          const hr: HyperScriptHelperFn;

                                                                                            variable html

                                                                                            const html: HyperScriptHelperFn;

                                                                                              variable i

                                                                                              const i: HyperScriptHelperFn;

                                                                                                variable iframe

                                                                                                const iframe: HyperScriptHelperFn;

                                                                                                  variable img

                                                                                                  const img: HyperScriptHelperFn;

                                                                                                    variable input

                                                                                                    const input: HyperScriptHelperFn;

                                                                                                      variable ins

                                                                                                      const ins: HyperScriptHelperFn;

                                                                                                        variable kbd

                                                                                                        const kbd: HyperScriptHelperFn;

                                                                                                          variable keygen

                                                                                                          const keygen: HyperScriptHelperFn;

                                                                                                            variable label

                                                                                                            const label: HyperScriptHelperFn;

                                                                                                              variable legend

                                                                                                              const legend: HyperScriptHelperFn;

                                                                                                                variable li

                                                                                                                const li: HyperScriptHelperFn;
                                                                                                                  const link: HyperScriptHelperFn;

                                                                                                                    variable main

                                                                                                                    const main: HyperScriptHelperFn;

                                                                                                                      variable map

                                                                                                                      const map: HyperScriptHelperFn;

                                                                                                                        variable mark

                                                                                                                        const mark: HyperScriptHelperFn;
                                                                                                                          const menu: HyperScriptHelperFn;

                                                                                                                            variable meta

                                                                                                                            const meta: HyperScriptHelperFn;
                                                                                                                              const nav: HyperScriptHelperFn;

                                                                                                                                variable noscript

                                                                                                                                const noscript: HyperScriptHelperFn;

                                                                                                                                  variable object

                                                                                                                                  const object: HyperScriptHelperFn;

                                                                                                                                    variable ol

                                                                                                                                    const ol: HyperScriptHelperFn;

                                                                                                                                      variable optgroup

                                                                                                                                      const optgroup: HyperScriptHelperFn;

                                                                                                                                        variable option

                                                                                                                                        const option: HyperScriptHelperFn;

                                                                                                                                          variable p

                                                                                                                                          const p: HyperScriptHelperFn;

                                                                                                                                            variable param

                                                                                                                                            const param: HyperScriptHelperFn;

                                                                                                                                              variable pre

                                                                                                                                              const pre: HyperScriptHelperFn;

                                                                                                                                                variable progress

                                                                                                                                                const progress: HyperScriptHelperFn;

                                                                                                                                                  variable q

                                                                                                                                                  const q: HyperScriptHelperFn;

                                                                                                                                                    variable rp

                                                                                                                                                    const rp: HyperScriptHelperFn;

                                                                                                                                                      variable rt

                                                                                                                                                      const rt: HyperScriptHelperFn;

                                                                                                                                                        variable ruby

                                                                                                                                                        const ruby: HyperScriptHelperFn;

                                                                                                                                                          variable s

                                                                                                                                                          const s: HyperScriptHelperFn;

                                                                                                                                                            variable samp

                                                                                                                                                            const samp: HyperScriptHelperFn;

                                                                                                                                                              variable script

                                                                                                                                                              const script: HyperScriptHelperFn;

                                                                                                                                                                variable section

                                                                                                                                                                const section: HyperScriptHelperFn;

                                                                                                                                                                  variable select

                                                                                                                                                                  const select: HyperScriptHelperFn;

                                                                                                                                                                    variable small

                                                                                                                                                                    const small: HyperScriptHelperFn;

                                                                                                                                                                      variable source

                                                                                                                                                                      const source: HyperScriptHelperFn;

                                                                                                                                                                        variable span

                                                                                                                                                                        const span: HyperScriptHelperFn;

                                                                                                                                                                          variable strong

                                                                                                                                                                          const strong: HyperScriptHelperFn;

                                                                                                                                                                            variable style

                                                                                                                                                                            const style: HyperScriptHelperFn;

                                                                                                                                                                              variable sub

                                                                                                                                                                              const sub: HyperScriptHelperFn;

                                                                                                                                                                                variable sup

                                                                                                                                                                                const sup: HyperScriptHelperFn;

                                                                                                                                                                                  variable svg

                                                                                                                                                                                  const svg: SVGHelperFn;

                                                                                                                                                                                    variable table

                                                                                                                                                                                    const table: HyperScriptHelperFn;

                                                                                                                                                                                      variable tbody

                                                                                                                                                                                      const tbody: HyperScriptHelperFn;

                                                                                                                                                                                        variable td

                                                                                                                                                                                        const td: HyperScriptHelperFn;

                                                                                                                                                                                          variable textarea

                                                                                                                                                                                          const textarea: HyperScriptHelperFn;

                                                                                                                                                                                            variable tfoot

                                                                                                                                                                                            const tfoot: HyperScriptHelperFn;

                                                                                                                                                                                              variable th

                                                                                                                                                                                              const th: HyperScriptHelperFn;

                                                                                                                                                                                                variable thead

                                                                                                                                                                                                const thead: HyperScriptHelperFn;

                                                                                                                                                                                                  variable title

                                                                                                                                                                                                  const title: HyperScriptHelperFn;

                                                                                                                                                                                                    variable tr

                                                                                                                                                                                                    const tr: HyperScriptHelperFn;

                                                                                                                                                                                                      variable u

                                                                                                                                                                                                      const u: HyperScriptHelperFn;

                                                                                                                                                                                                        variable ul

                                                                                                                                                                                                        const ul: HyperScriptHelperFn;

                                                                                                                                                                                                          variable video

                                                                                                                                                                                                          const video: HyperScriptHelperFn;

                                                                                                                                                                                                            Functions

                                                                                                                                                                                                            function makeDOMDriver

                                                                                                                                                                                                            makeDOMDriver: (
                                                                                                                                                                                                            container: string | Element | DocumentFragment,
                                                                                                                                                                                                            options?: DOMDriverOptions
                                                                                                                                                                                                            ) => any;

                                                                                                                                                                                                              function mockDOMSource

                                                                                                                                                                                                              mockDOMSource: (mockConfig: MockConfig) => MockedDOMSource;

                                                                                                                                                                                                                function thunk

                                                                                                                                                                                                                thunk: {
                                                                                                                                                                                                                (sel: string, fn: Function, args: Array<any>): Thunk;
                                                                                                                                                                                                                (sel: string, key: any, fn: Function, args: any[]): Thunk;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  Classes

                                                                                                                                                                                                                  class MainDOMSource

                                                                                                                                                                                                                  class MainDOMSource {}

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                    _rootElement$: any,
                                                                                                                                                                                                                    _sanitation$: any,
                                                                                                                                                                                                                    _namespace: Scope[],
                                                                                                                                                                                                                    _isolateModule: IsolateModule,
                                                                                                                                                                                                                    _eventDelegator: EventDelegator,
                                                                                                                                                                                                                    _name: string
                                                                                                                                                                                                                    );

                                                                                                                                                                                                                      property isolateSink

                                                                                                                                                                                                                      isolateSink: IsolateSink<any>;

                                                                                                                                                                                                                        property isolateSource

                                                                                                                                                                                                                        isolateSource: (source: MainDOMSource, scope: string) => MainDOMSource;

                                                                                                                                                                                                                          property namespace

                                                                                                                                                                                                                          readonly namespace: Scope[];

                                                                                                                                                                                                                            method dispose

                                                                                                                                                                                                                            dispose: () => void;

                                                                                                                                                                                                                              method element

                                                                                                                                                                                                                              element: () => any;

                                                                                                                                                                                                                                method elements

                                                                                                                                                                                                                                elements: () => any;

                                                                                                                                                                                                                                  method events

                                                                                                                                                                                                                                  events: <K extends keyof HTMLElementEventMap>(
                                                                                                                                                                                                                                  eventType: K,
                                                                                                                                                                                                                                  options?: EventsFnOptions,
                                                                                                                                                                                                                                  bubbles?: boolean
                                                                                                                                                                                                                                  ) => any;

                                                                                                                                                                                                                                    method select

                                                                                                                                                                                                                                    select: {
                                                                                                                                                                                                                                    <T extends keyof SpecialSelector>(selector: T): SpecialSelector[T];
                                                                                                                                                                                                                                    (selector: string): MainDOMSource;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      class MockedDOMSource

                                                                                                                                                                                                                                      class MockedDOMSource {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(_mockConfig: MockConfig);

                                                                                                                                                                                                                                          method element

                                                                                                                                                                                                                                          element: () => any;

                                                                                                                                                                                                                                            method elements

                                                                                                                                                                                                                                            elements: () => any;

                                                                                                                                                                                                                                              method events

                                                                                                                                                                                                                                              events: (eventType: string, options?: EventsFnOptions, bubbles?: boolean) => any;

                                                                                                                                                                                                                                                method isolateSink

                                                                                                                                                                                                                                                isolateSink: (sink: any, scope: string) => any;

                                                                                                                                                                                                                                                  method isolateSource

                                                                                                                                                                                                                                                  isolateSource: (source: MockedDOMSource, scope: string) => MockedDOMSource;

                                                                                                                                                                                                                                                    method select

                                                                                                                                                                                                                                                    select: (selector: string) => MockedDOMSource;

                                                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                                                      interface CycleDOMEvent

                                                                                                                                                                                                                                                      interface CycleDOMEvent extends Event {}

                                                                                                                                                                                                                                                        property ownerTarget

                                                                                                                                                                                                                                                        ownerTarget: Element;

                                                                                                                                                                                                                                                          property propagationHasBeenStopped

                                                                                                                                                                                                                                                          propagationHasBeenStopped: boolean;

                                                                                                                                                                                                                                                            interface DOMDriverOptions

                                                                                                                                                                                                                                                            interface DOMDriverOptions {}

                                                                                                                                                                                                                                                              property modules

                                                                                                                                                                                                                                                              modules?: Array<Partial<Module>>;

                                                                                                                                                                                                                                                                method reportSnabbdomError

                                                                                                                                                                                                                                                                reportSnabbdomError: (err: any) => void;

                                                                                                                                                                                                                                                                  interface EventsFnOptions

                                                                                                                                                                                                                                                                  interface EventsFnOptions {}

                                                                                                                                                                                                                                                                    property bubbles

                                                                                                                                                                                                                                                                    bubbles?: boolean;

                                                                                                                                                                                                                                                                      property passive

                                                                                                                                                                                                                                                                      passive?: boolean;

                                                                                                                                                                                                                                                                        property preventDefault

                                                                                                                                                                                                                                                                        preventDefault?: PreventDefaultOpt;

                                                                                                                                                                                                                                                                          property useCapture

                                                                                                                                                                                                                                                                          useCapture?: boolean;

                                                                                                                                                                                                                                                                            interface Thunk

                                                                                                                                                                                                                                                                            interface Thunk extends VNode {}

                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                              data: ThunkData;

                                                                                                                                                                                                                                                                                interface ThunkData

                                                                                                                                                                                                                                                                                interface ThunkData extends VNodeData {}

                                                                                                                                                                                                                                                                                  property args

                                                                                                                                                                                                                                                                                  args: Array<any>;

                                                                                                                                                                                                                                                                                    method fn

                                                                                                                                                                                                                                                                                    fn: () => any;

                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                      type DOMSource

                                                                                                                                                                                                                                                                                      type DOMSource = MainDOMSource | DocumentDOMSource | BodyDOMSource;

                                                                                                                                                                                                                                                                                        type MockConfig

                                                                                                                                                                                                                                                                                        type MockConfig = {
                                                                                                                                                                                                                                                                                        [name: string]: FantasyObservable<any> | MockConfig;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          Namespaces

                                                                                                                                                                                                                                                                                          namespace simulant

                                                                                                                                                                                                                                                                                          module 'simulant' {}

                                                                                                                                                                                                                                                                                            Package Files (8)

                                                                                                                                                                                                                                                                                            Dependencies (4)

                                                                                                                                                                                                                                                                                            Dev Dependencies (26)

                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@cycle/dom.

                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@cycle/dom)
                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@cycle/dom"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>