Logo for jsDocs.io

@fortawesome/fontawesome-svg-core

  • Version 7.1.0
  • Published
  • 439 kB
  • 1 dependency
  • MIT license

Install

npm i @fortawesome/fontawesome-svg-core
yarn add @fortawesome/fontawesome-svg-core
pnpm add @fortawesome/fontawesome-svg-core

Overview

The iconic font, CSS, and SVG framework

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable config

const config: Config;

    variable dom

    const dom: DOM;

      variable library

      const library: Library;

        variable parse

        const parse: {
            transform(transformString: string): Transform;
            icon(
                parseIconString:
                    | string
                    | { prefix: IconPrefix; iconName: IconName }
                    | [string | IconPrefix, string | IconName]
            ): IconLookup;
        };

          Functions

          function counter

          counter: (content: string | number, params?: CounterParams) => Counter;

            function findIconDefinition

            findIconDefinition: (iconLookup: IconLookup) => IconDefinition;

              function icon

              icon: (icon: IconName | IconLookup, params?: IconParams) => Icon;

                function layer

                layer: (
                    assembler: (
                        addLayerCallback: (layerToAdd: IconOrText | IconOrText[]) => void
                    ) => void,
                    params?: LayerParams
                ) => Layer;

                  function noAuto

                  noAuto: () => void;

                    function text

                    text: (content: string, params?: TextParams) => Text;

                      function toHtml

                      toHtml: { (content: any): string; (abstractNodes: AbstractElement): string };

                        Interfaces

                        interface AbstractElement

                        interface AbstractElement {}

                          property attributes

                          attributes: any;

                            property children

                            children?: AbstractElement[];

                              property tag

                              tag: string;

                                interface Attributes

                                interface Attributes {}

                                  index signature

                                  [key: string]: number | string;

                                    interface Config

                                    interface Config {}

                                      property autoAddCss

                                      autoAddCss: boolean;

                                        property autoReplaceSvg

                                        autoReplaceSvg: boolean | 'nest';

                                          property cssPrefix

                                          cssPrefix: string;

                                            property familyDefault

                                            familyDefault: IconFamily;

                                              property familyPrefix

                                              familyPrefix: string;

                                                property keepOriginalSource

                                                keepOriginalSource: boolean;

                                                  property measurePerformance

                                                  measurePerformance: boolean;

                                                    property mutateApproach

                                                    mutateApproach: 'async' | 'sync';

                                                      property observeMutations

                                                      observeMutations: boolean;

                                                        property replacementClass

                                                        replacementClass: string;

                                                          property searchPseudoElements

                                                          searchPseudoElements: boolean;

                                                            property searchPseudoElementsFullScan

                                                            searchPseudoElementsFullScan: boolean;

                                                              property searchPseudoElementsWarnings

                                                              searchPseudoElementsWarnings: boolean;

                                                                property showMissingIcons

                                                                showMissingIcons: boolean;

                                                                  property styleDefault

                                                                  styleDefault: IconPrefix | CssStyleClass | IconStyle;

                                                                    interface Counter

                                                                    interface Counter extends FontawesomeObject {}

                                                                      property type

                                                                      readonly type: 'counter';

                                                                        interface CounterParams

                                                                        interface CounterParams extends Params {}

                                                                          interface DOM

                                                                          interface DOM {}

                                                                            method css

                                                                            css: () => string;

                                                                              method i2svg

                                                                              i2svg: (params?: { node: Node; callback?: () => void }) => Promise<void>;

                                                                                method insertCss

                                                                                insertCss: () => string;

                                                                                  method watch

                                                                                  watch: () => void;

                                                                                    interface FontawesomeObject

                                                                                    interface FontawesomeObject {}

                                                                                      property abstract

                                                                                      readonly abstract: AbstractElement[];

                                                                                        property html

                                                                                        readonly html: string[];

                                                                                          property node

                                                                                          readonly node: HTMLCollection;

                                                                                            interface Icon

                                                                                            interface Icon extends FontawesomeObject, IconDefinition {}

                                                                                              property type

                                                                                              readonly type: 'icon';

                                                                                                interface IconParams

                                                                                                interface IconParams extends Params {}

                                                                                                  property mask

                                                                                                  mask?: IconLookup;

                                                                                                    property maskId

                                                                                                    maskId?: string;

                                                                                                      property symbol

                                                                                                      symbol?: FaSymbol;

                                                                                                        property transform

                                                                                                        transform?: Transform;

                                                                                                          interface Layer

                                                                                                          interface Layer extends FontawesomeObject {}

                                                                                                            property type

                                                                                                            readonly type: 'layer';

                                                                                                              interface LayerParams

                                                                                                              interface LayerParams {}

                                                                                                                property classes

                                                                                                                classes?: string | string[];

                                                                                                                  interface Library

                                                                                                                  interface Library {}

                                                                                                                    method add

                                                                                                                    add: (
                                                                                                                        ...definitions: Array<IconDefinitionOrPack | IconDefinitionOrPack[]>
                                                                                                                    ) => void;

                                                                                                                      method reset

                                                                                                                      reset: () => void;

                                                                                                                        interface Params

                                                                                                                        interface Params {}

                                                                                                                          property attributes

                                                                                                                          attributes?: Attributes;

                                                                                                                            property classes

                                                                                                                            classes?: string | string[];

                                                                                                                              property styles

                                                                                                                              styles?: Styles;

                                                                                                                                property title

                                                                                                                                title?: string;

                                                                                                                                  property titleId

                                                                                                                                  titleId?: string;

                                                                                                                                    interface Styles

                                                                                                                                    interface Styles {}

                                                                                                                                      index signature

                                                                                                                                      [key: string]: string;

                                                                                                                                        interface Text

                                                                                                                                        interface Text extends FontawesomeObject {}

                                                                                                                                          property type

                                                                                                                                          readonly type: 'text';

                                                                                                                                            interface TextParams

                                                                                                                                            interface TextParams extends Params {}

                                                                                                                                              property transform

                                                                                                                                              transform?: Transform;

                                                                                                                                                interface Transform

                                                                                                                                                interface Transform {}

                                                                                                                                                  property flipX

                                                                                                                                                  flipX?: boolean;

                                                                                                                                                    property flipY

                                                                                                                                                    flipY?: boolean;

                                                                                                                                                      property rotate

                                                                                                                                                      rotate?: number;

                                                                                                                                                        property size

                                                                                                                                                        size?: number;

                                                                                                                                                          property x

                                                                                                                                                          x?: number;

                                                                                                                                                            property y

                                                                                                                                                            y?: number;

                                                                                                                                                              Type Aliases

                                                                                                                                                              type FaSymbol

                                                                                                                                                              type FaSymbol = string | boolean;

                                                                                                                                                                type FlipProp

                                                                                                                                                                type FlipProp = 'horizontal' | 'vertical' | 'both';

                                                                                                                                                                  type IconProp

                                                                                                                                                                  type IconProp = IconName | [IconPrefix, IconName] | IconLookup;

                                                                                                                                                                    type PullProp

                                                                                                                                                                    type PullProp = 'left' | 'right';

                                                                                                                                                                      type RotateProp

                                                                                                                                                                      type RotateProp = 90 | 180 | 270;

                                                                                                                                                                        type SizeProp

                                                                                                                                                                        type SizeProp =
                                                                                                                                                                            | '2xs'
                                                                                                                                                                            | 'xs'
                                                                                                                                                                            | 'sm'
                                                                                                                                                                            | 'lg'
                                                                                                                                                                            | 'xl'
                                                                                                                                                                            | '2xl'
                                                                                                                                                                            | '1x'
                                                                                                                                                                            | '2x'
                                                                                                                                                                            | '3x'
                                                                                                                                                                            | '4x'
                                                                                                                                                                            | '5x'
                                                                                                                                                                            | '6x'
                                                                                                                                                                            | '7x'
                                                                                                                                                                            | '8x'
                                                                                                                                                                            | '9x'
                                                                                                                                                                            | '10x';

                                                                                                                                                                          Package Files (1)

                                                                                                                                                                          Dependencies (1)

                                                                                                                                                                          Dev Dependencies (0)

                                                                                                                                                                          No dev dependencies.

                                                                                                                                                                          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/@fortawesome/fontawesome-svg-core.

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