Definitions

All listed definitions are available in the nuxt-booster package.

Example

import type { FontOption } from 'nuxt-booster';

Type

type HTMLCrossOriginAttribute = 'anonymous' | 'use-credentials' | '';
type CrossOrigin = boolean | HTMLCrossOriginAttribute | undefined;

Interface

FontOption

interface FontOption {
  family: string;
  fallback: string[];
  variances: FontOptionVariance[];
  locals?: string[];
}

FontOptionVariance

interface FontOptionVariance {
  style: string;
  weight: string | number;
  sources: FontOptionVarianceSource[];
}

FontOptionVarianceSource

interface FontOptionVarianceSource {
  src: string;
  type: string;
}

PreparedFontOption

interface PreparedFontOption extends FontOption {
  variances: PreparedFontOptionVariance[];
}

PreparedFontOptionVariance

interface PreparedFontOptionVariance extends FontOptionVariance {
  sources: PreparedFontOptionVarianceSource[];
  type: string;
  src: string;
  hash?: string;
}

PreparedFontOptionVarianceSource

interface PreparedFontOptionVarianceSource extends FontOptionVarianceSource {
  className: string;
  style: string;
}

ModulePublicRuntimeConfig

interface ModulePublicRuntimeConfig {
  debug: boolean;
  lazyOffsetComponent: string;
  lazyOffsetAsset: string;
  usedFontaine: boolean;
}

ModuleOptions

interface ModuleOptions {
  debug: boolean;
  crossorigin?: CrossOrigin;
  disableNuxtFontaine?: boolean;
  disableNuxtImage?: boolean;
  optimizeSSR?: boolean | OptimizeSSR;
  detection?: Detection;
  performanceMetrics?: PerformanceMetrics;
  fonts?: FontOption[];
  targetFormats?: string[];
  densities?: string;
  /**
   * IntersectionObserver rootMargin for Components and Assets
   */
  lazyOffset: LazyOffset;
  runOptions?: RunOptions;
  experimental?: Experimental;
}

PerformanceMetrics

interface PerformanceMetrics {
  device?: {
    hardwareConcurrency: {
      min: number;
      max: number;
    };
    deviceMemory: {
      min: number;
    };
  };
  timing?: {
    fcp: number;
    dcl: number;
  };
}

OptimizeSSR

interface OptimizeSSR {
  cleanPreloads?: boolean;
  cleanPrefetches?: boolean;
  inlineStyles?: boolean;
}

Experimental

interface Experimental {
  fallbackInit?:
    | {
        duration?: number;
      }
    | boolean;
}

Detection

interface Detection {
  performance?: boolean;
  browserSupport?: boolean;
  battery?: boolean;
}

LazyOffset

interface LazyOffset {
  component?: string;
  asset?: string;
}

RunOptions

interface RunOptions {
  maxTime?: number;
  threshold?: number;
}

BoosterProvide

interface BoosterProvide {
  getImageSize: (src: string) => Promise<{
    width: number;
    height: number;
  }>;
  densities: string;
  targetFormats: string[];
  crossorigin: CrossOrigin;
}

ISource

export interface ISource {
  src: string;
  media?: string;
  sizes?: Record<string, string | number>;
  width?: number;
  height?: number;
  format?: string;
  quality?: number;
  preload?: boolean;
  modifiers?: Partial<ImageModifiers>;
  provider?: string;
  preset?: string;
  densities?: string;
}

DirectiveGetFontArguments

interface DirectiveGetFontArguments {
  family: FontFamily;
  weight?: FontWeight;
  style?: FontStyle;
  options?: DirectiveGetFontOptions;
}

DirectiveGetFontOptions

interface DirectiveGetFontOptions {
  selector?: string;
  media?: string;
}

DirectiveGetFontResult

interface DirectiveGetFontResult {
  runtimeConfig: ModulePublicRuntimeConfig;
  isCritical: boolean;
  fontCollection: FontCollection;
  definition: Font;
}

HeadFontCollector

interface HeadFontCollector {
  push: (description: HeadFontCollectorDescription) => HeadFontCollectorEntry;
  collection: Ref<FontsCollection>;
}

HeadFontCollectorDescription

interface HeadFontCollectorDescription {
  options: ModulePublicRuntimeConfig;
  fontCollection: FontCollection;
  isCritical: boolean;
}

HeadFontCollectorEntry

interface HeadFontCollectorEntry {
  dispose: () => void;
}

ObservableOptions

interface ObservableOptions {
  root?: HTMLElement;
  rootMargin?: string;
  threshold?: number | number[];
  trackVisibility?: boolean;
  delay?: number;
}

ObservableHTMLElement

interface ObservableHTMLElement extends HTMLElement {
  observables: Map<string, IntersectionObservable>;
}

Declare

NuxtApp

declare module 'nuxt/app' {
  interface NuxtApp {
    $booster: BoosterProvide;
  }
}

ComponentCustomProperties

declare module 'vue' {
  interface ComponentCustomProperties {
    $booster: {
      targetFormats: string[];
    };
  }
  interface GlobalComponents {
    $booster: BoosterProvide;
  }
  interface GlobalDirectives {
    vFont: Directive;
  }
}

BoosterProvide (Module)

declare module './module' {
  interface BoosterProvide {
    head: HeadFontCollector;
  }
}