@tabler/core 1.5.1 → 1.6.1

package/js/src/bootstrap/tooltip.ts

@@ -9,9 +9,10 @@ import * as Popper from '@popperjs/core'
 import BaseComponent from './base-component'
 import EventHandler from './dom/event-handler'
 import Manipulator from './dom/manipulator'
-import { execute, findShadowRoot, getElement, getUID, isRTL, noop } from './util/index'
+import { defineJQueryPlugin, execute, findShadowRoot, getElement, getUID, isRTL, noop } from './util/index'
 import { DefaultAllowlist } from './util/sanitizer'
 import TemplateFactory from './util/template-factory'
+import type { AllowList, ComponentConfig as BaseComponentConfig, JQueryCollectionLike, SanitizeFn } from './types'
 
 /**
  * Constants
@@ -45,13 +46,41 @@ const EVENT_FOCUSOUT = 'focusout'
 const EVENT_MOUSEENTER = 'mouseenter'
 const EVENT_MOUSELEAVE = 'mouseleave'
 
-interface ComponentConfig {
-  [key: string]: any
+type PopperOffsetData = { placement: Popper.Placement; reference: Popper.Rect; popper: Popper.Rect }
+type PopperOffsetFunction = (popperData: PopperOffsetData) => number[]
+type PopperConfigFunction = (defaultConfig: Partial<Popper.Options>) => Partial<Popper.Options>
+
+export type TooltipDelay = number | { show: number; hide: number }
+export type TooltipContent = string | HTMLElement | null | ((this: HTMLElement, element: HTMLElement) => string | HTMLElement | null)
+// Keys are selectors inside the template, values the content for that slot
+export type TooltipContentMap = Record<string, TooltipContent>
+export type TooltipPlacement = string | ((this: Tooltip, tip: HTMLElement, element: HTMLElement) => string)
+
+export type TooltipConfig = {
+  allowList: AllowList
+  animation: boolean
+  boundary: Popper.Boundary
+  container: HTMLElement | string | false
+  customClass: string | ((this: HTMLElement, element: HTMLElement) => string)
+  delay: TooltipDelay
+  fallbackPlacements: string[]
+  html: boolean
+  offset: number[] | string | ((popperData: PopperOffsetData, element: HTMLElement) => number[])
+  placement: TooltipPlacement
+  popperConfig: Partial<Popper.Options> | PopperConfigFunction | null
+  sanitize: boolean
+  sanitizeFn: SanitizeFn | null
+  selector: string | false
+  template: string
+  title: TooltipContent
+  trigger: string
 }
 
-interface ComponentConfigType {
-  [key: string]: string
-}
+type ComponentConfig = TooltipConfig
+
+export type TooltipConfigInput = Partial<TooltipConfig> & Record<string, unknown>
+
+type ComponentConfigInput = TooltipConfigInput
 
 const AttachmentMap: Record<string, string> = {
   AUTO: 'auto',
@@ -81,7 +110,7 @@ const Default: ComponentConfig = {
   trigger: 'hover focus',
 }
 
-const DefaultType: ComponentConfigType = {
+const DefaultType: Record<keyof ComponentConfig, string> = {
   allowList: 'object',
   animation: 'boolean',
   boundary: '(string|element)',
@@ -106,17 +135,19 @@ const DefaultType: ComponentConfigType = {
  */
 
 class Tooltip extends BaseComponent {
+  declare _element: HTMLElement
+  declare _config: ComponentConfig
   _isEnabled: boolean
   _timeout: ReturnType<typeof setTimeout> | number
   _isHovered: boolean | null
   _activeTrigger: Record<string, boolean>
   _popper: Popper.Instance | null
   _templateFactory: TemplateFactory | null
-  _newContent: Record<string, any> | null
+  _newContent: TooltipContentMap | null
   tip: HTMLElement | null
-  _hideModalHandler: (() => void) | null
+  _hideModalHandler: () => void
 
-  constructor(element: HTMLElement | string, config?: Partial<ComponentConfig>) {
+  constructor(element: HTMLElement | string, config?: ComponentConfigInput) {
     if (typeof Popper === 'undefined') {
       throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org/docs/v2/)")
     }
@@ -132,7 +163,11 @@ class Tooltip extends BaseComponent {
     this._newContent = null
 
     this.tip = null
-    this._hideModalHandler = null
+    this._hideModalHandler = () => {
+      if (this._element) {
+        this.hide()
+      }
+    }
 
     this._setListeners()
 
@@ -145,7 +180,7 @@ class Tooltip extends BaseComponent {
     return Default
   }
 
-  static get DefaultType(): ComponentConfigType {
+  static get DefaultType(): Record<keyof ComponentConfig, string> {
     return DefaultType
   }
 
@@ -204,29 +239,30 @@ class Tooltip extends BaseComponent {
     const shadowRoot = findShadowRoot(this._element)
     const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element)
 
-    if (showEvent.defaultPrevented || !isInTheDom) {
+    if (showEvent?.defaultPrevented || !isInTheDom) {
       return
     }
 
     this._disposePopper()
 
-    const tip = this._getTipElement()
+    const tip = this._getTipElement()!
 
-    this._element.setAttribute('aria-describedby', tip!.getAttribute('id')!)
+    this._element.setAttribute('aria-describedby', tip.getAttribute('id')!)
 
     const { container } = this._config
 
     if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
-      container.append(tip)
+      // `_configAfterMerge` resolved the container to an element
+      ;(container as HTMLElement).append(tip)
       EventHandler.trigger(this._element, (this.constructor as typeof Tooltip).eventName(EVENT_INSERTED))
     }
 
-    this._popper = this._createPopper(tip!)
+    this._popper = this._createPopper(tip)
 
     tip!.classList.add(CLASS_NAME_SHOW)
 
     if ('ontouchstart' in document.documentElement) {
-      for (const element of [].concat(...(document.body.children as any))) {
+      for (const element of Array.from(document.body.children)) {
         EventHandler.on(element, 'mouseover', noop)
       }
     }
@@ -250,7 +286,7 @@ class Tooltip extends BaseComponent {
     }
 
     const hideEvent = EventHandler.trigger(this._element, (this.constructor as typeof Tooltip).eventName(EVENT_HIDE))
-    if (hideEvent.defaultPrevented) {
+    if (hideEvent?.defaultPrevented) {
       return
     }
 
@@ -258,7 +294,7 @@ class Tooltip extends BaseComponent {
     tip!.classList.remove(CLASS_NAME_SHOW)
 
     if ('ontouchstart' in document.documentElement) {
-      for (const element of [].concat(...(document.body.children as any))) {
+      for (const element of Array.from(document.body.children)) {
         EventHandler.off(element, 'mouseover', noop)
       }
     }
@@ -302,7 +338,7 @@ class Tooltip extends BaseComponent {
     return this.tip
   }
 
-  _createTipElement(content: Record<string, any>): HTMLElement | null {
+  _createTipElement(content: TooltipContentMap): HTMLElement | null {
     const tip = this._getTemplateFactory(content).toHtml() as HTMLElement
 
     if (!tip) {
@@ -323,7 +359,7 @@ class Tooltip extends BaseComponent {
     return tip
   }
 
-  setContent(content: Record<string, any>): void {
+  setContent(content: TooltipContentMap): void {
     this._newContent = content
     if (this._isShown()) {
       this._disposePopper()
@@ -331,7 +367,7 @@ class Tooltip extends BaseComponent {
     }
   }
 
-  _getTemplateFactory(content: Record<string, any>): TemplateFactory {
+  _getTemplateFactory(content: TooltipContentMap): TemplateFactory {
     if (this._templateFactory) {
       this._templateFactory.changeContent(content)
     } else {
@@ -345,13 +381,13 @@ class Tooltip extends BaseComponent {
     return this._templateFactory
   }
 
-  _getContentForTemplate(): Record<string, any> {
+  _getContentForTemplate(): TooltipContentMap {
     return {
       [SELECTOR_TOOLTIP_INNER]: this._getTitle(),
     }
   }
 
-  _getTitle(): string {
+  _getTitle(): string | HTMLElement {
     return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title') || this._element.getAttribute('data-tblr-original-title') || ''
   }
 
@@ -373,7 +409,7 @@ class Tooltip extends BaseComponent {
     return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment))
   }
 
-  _getOffset(): number[] | ((popperData: any) => number[]) {
+  _getOffset(): number[] | PopperOffsetFunction {
     const { offset } = this._config
 
     if (typeof offset === 'string') {
@@ -381,14 +417,14 @@ class Tooltip extends BaseComponent {
     }
 
     if (typeof offset === 'function') {
-      return (popperData: any) => (offset as Function)(popperData, this._element)
+      return (popperData: PopperOffsetData) => offset(popperData, this._element)
     }
 
-    return offset as number[]
+    return offset
   }
 
-  _resolvePossibleFunction(arg: any): any {
-    return execute(arg, [this._element, this._element])
+  _resolvePossibleFunction<T>(arg: T | ((this: HTMLElement, element: HTMLElement) => T)): T {
+    return execute(arg, [this._element, this._element]) as T
   }
 
   _getPopperConfig(attachment: string): Partial<Popper.Options> {
@@ -423,7 +459,7 @@ class Tooltip extends BaseComponent {
           name: 'preSetPlacement',
           enabled: true,
           phase: 'beforeMain',
-          fn: (data: any) => {
+          fn: (data: Popper.ModifierArguments<Record<string, unknown>>) => {
             this._getTipElement()!.setAttribute('data-popper-placement', data.state.placement)
           },
         },
@@ -465,12 +501,6 @@ class Tooltip extends BaseComponent {
       }
     }
 
-    this._hideModalHandler = () => {
-      if (this._element) {
-        this.hide()
-      }
-    }
-
     EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler)
   }
 
@@ -501,7 +531,7 @@ class Tooltip extends BaseComponent {
       if (this._isHovered) {
         this.show()
       }
-    }, this._config.delay.show)
+    }, this._getDelay().show)
   }
 
   _leave(): void {
@@ -515,7 +545,12 @@ class Tooltip extends BaseComponent {
       if (!this._isHovered) {
         this.hide()
       }
-    }, this._config.delay.hide)
+    }, this._getDelay().hide)
+  }
+
+  _getDelay(): { show: number; hide: number } {
+    const { delay } = this._config
+    return typeof delay === 'number' ? { show: delay, hide: delay } : delay
   }
 
   _setTimeout(handler: () => void, timeout: number): void {
@@ -527,7 +562,7 @@ class Tooltip extends BaseComponent {
     return Object.values(this._activeTrigger).includes(true)
   }
 
-  _getConfig(config: Partial<ComponentConfig>): ComponentConfig {
+  _getConfig(config?: ComponentConfigInput): ComponentConfig {
     const dataAttributes = Manipulator.getDataAttributes(this._element)
 
     for (const dataAttribute of Object.keys(dataAttributes)) {
@@ -536,18 +571,18 @@ class Tooltip extends BaseComponent {
       }
     }
 
-    config = {
+    let merged: Record<string, unknown> = {
       ...dataAttributes,
       ...(typeof config === 'object' && config ? config : {}),
     }
-    config = this._mergeConfigObj(config)
-    config = this._configAfterMerge(config)
-    this._typeCheckConfig(config)
-    return config
+    merged = this._mergeConfigObj(merged)
+    merged = this._configAfterMerge(merged as ComponentConfig)
+    this._typeCheckConfig(merged)
+    return merged as ComponentConfig
   }
 
   _configAfterMerge(config: ComponentConfig): ComponentConfig {
-    config.container = config.container === false ? document.body : getElement(config.container)
+    config.container = config.container === false ? document.body : (getElement(config.container) as HTMLElement)
 
     if (typeof config.delay === 'number') {
       config.delay = {
@@ -556,22 +591,25 @@ class Tooltip extends BaseComponent {
       }
     }
 
-    if (typeof config.title === 'number') {
-      config.title = config.title.toString()
+    // Numbers are accepted at runtime (`data-bs-title="42"`) even though the type says string
+    const raw = config as Record<string, unknown>
+    if (typeof raw.title === 'number') {
+      raw.title = raw.title.toString()
     }
 
-    if (typeof config.content === 'number') {
-      config.content = config.content.toString()
+    if (typeof raw.content === 'number') {
+      raw.content = raw.content.toString()
     }
 
     return config
   }
 
-  _getDelegateConfig(): Partial<ComponentConfig> {
-    const config: Partial<ComponentConfig> = {}
+  _getDelegateConfig(): ComponentConfigInput {
+    const config: Record<string, unknown> = {}
+    const defaults = (this.constructor as typeof Tooltip).Default as Record<string, unknown>
 
     for (const [key, value] of Object.entries(this._config)) {
-      if ((this.constructor as typeof Tooltip).Default[key] !== value) {
+      if (defaults[key] !== value) {
         config[key] = value
       }
     }
@@ -593,6 +631,24 @@ class Tooltip extends BaseComponent {
       this.tip = null
     }
   }
+
+  static jQueryInterface(this: JQueryCollectionLike, config?: unknown): unknown {
+    return this.each(function (this: HTMLElement) {
+      const data = Tooltip.getOrCreateInstance(this, config as BaseComponentConfig) as unknown as Record<string, (arg?: unknown) => unknown>
+
+      if (typeof config !== 'string') {
+        return
+      }
+
+      if (typeof data[config] === 'undefined') {
+        throw new TypeError(`No method named "${config}"`)
+      }
+
+      data[config]()
+    })
+  }
 }
 
+defineJQueryPlugin(Tooltip)
+
 export default Tooltip

package/js/src/bootstrap/types.ts

@@ -5,7 +5,7 @@
  * --------------------------------------------------------------------------
  */
 
-export type ComponentConfig = Record<string, any>
+export type ComponentConfig = Record<string, unknown>
 
 export type ComponentConfigType = Record<string, string>
 
@@ -25,3 +25,32 @@ export interface BaseComponentStatic extends ConfigStatic {
 export type AllowList = Record<string, (string | RegExp)[]>
 
 export type SanitizeFn = (unsafeHtml: string) => string
+
+export interface JQueryEventLike {
+  isPropagationStopped(): boolean
+  isImmediatePropagationStopped(): boolean
+  isDefaultPrevented(): boolean
+  preventDefault(): void
+}
+
+export interface JQueryCollectionLike {
+  trigger(event: JQueryEventLike): unknown
+  each(callback: (this: HTMLElement, index: number) => void): unknown
+}
+
+export interface JQueryPluginFunction {
+  (this: JQueryCollectionLike, config?: unknown, ...args: unknown[]): unknown
+  Constructor?: unknown
+  noConflict?: () => JQueryPluginFunction
+}
+
+export interface JQueryStaticLike {
+  fn: Record<string, JQueryPluginFunction>
+  (selector: EventTarget): JQueryCollectionLike
+  Event(name: string, args?: Record<string, unknown>): JQueryEventLike
+}
+
+export interface JQueryPluginStatic {
+  NAME: string
+  jQueryInterface: JQueryPluginFunction
+}

package/js/src/bootstrap/util/backdrop.ts

@@ -15,7 +15,7 @@ const CLASS_NAME_FADE = 'fade'
 const CLASS_NAME_SHOW = 'show'
 const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`
 
-interface BackdropConfig {
+type BackdropConfig = {
   className: string
   clickCallback: (() => void) | null
   isAnimated: boolean

package/js/src/bootstrap/util/component-functions.ts

@@ -9,11 +9,34 @@ import EventHandler from '../dom/event-handler.js'
 import SelectorEngine from '../dom/selector-engine.js'
 import { isDisabled } from './index'
 
+type ComponentInstance = unknown
+
+interface PluginComponent {
+  NAME: string
+  getOrCreateInstance(element: HTMLElement | string | null): ComponentInstance
+}
+
+interface EventActionData {
+  targets: HTMLElement[]
+  event: Event
+}
+
+interface PluginEventActionData extends EventActionData {
+  instances: ComponentInstance[]
+}
+
 interface DismissibleComponent {
   EVENT_KEY: string
   NAME: string
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  getOrCreateInstance(element: HTMLElement | string | null): any
+  getOrCreateInstance(element: HTMLElement | string | null): ComponentInstance
+}
+
+const callMethod = (instance: ComponentInstance, method: string): void => {
+  const callable = (instance as Record<string, unknown>)[method]
+
+  if (typeof callable === 'function') {
+    callable.call(instance)
+  }
 }
 
 const enableDismissTrigger = (component: DismissibleComponent, method = 'hide'): void => {
@@ -30,10 +53,56 @@ const enableDismissTrigger = (component: DismissibleComponent, method = 'hide'):
     }
 
     const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`)
-    const instance = component.getOrCreateInstance(target)
+    callMethod(component.getOrCreateInstance(target), method)
+  })
+}
 
-    instance[method]()
+const eventAction = (onEvent: string, stringSelector: string, callback: (data: EventActionData) => void): void => {
+  const selector = `${stringSelector}:not(.disabled):not(:disabled)`
+
+  EventHandler.on(document, onEvent, selector, function (this: HTMLElement, event: Event) {
+    if (['A', 'AREA'].includes(this.tagName)) {
+      event.preventDefault()
+    }
+
+    const targetSelector = SelectorEngine.getSelectorFromElement(this)
+    const targets = targetSelector ? SelectorEngine.find(targetSelector) : [this]
+
+    callback({ targets, event })
+  })
+}
+
+const eventActionOnPlugin = (Plugin: PluginComponent, onEvent: string, stringSelector: string, method: string, callback: ((data: PluginEventActionData) => void) | null = null): void => {
+  eventAction(`${onEvent}.${Plugin.NAME}`, stringSelector, (data) => {
+    const instances = data.targets.filter(Boolean).map((element) => Plugin.getOrCreateInstance(element))
+
+    if (typeof callback === 'function') {
+      callback({ ...data, instances })
+    }
+
+    for (const instance of instances) {
+      callMethod(instance, method)
+    }
   })
 }
 
-export { enableDismissTrigger }
+/**
+ * Creates the component for every element that matches on page load. One
+ * element with a broken config must not stop the rest of the bundle, so the
+ * error is logged and the loop goes on.
+ */
+const initAll = (selector: string, Plugin: PluginComponent, filter: ((element: HTMLElement) => boolean) | null = null): void => {
+  for (const element of SelectorEngine.find(selector)) {
+    if (filter && !filter(element)) {
+      continue
+    }
+
+    try {
+      Plugin.getOrCreateInstance(element)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+}
+
+export { enableDismissTrigger, eventAction, eventActionOnPlugin, initAll }

package/js/src/bootstrap/util/focustrap.ts

@@ -20,7 +20,7 @@ const TAB_KEY = 'Tab'
 const TAB_NAV_FORWARD = 'forward'
 const TAB_NAV_BACKWARD = 'backward'
 
-interface FocusTrapConfig {
+type FocusTrapConfig = {
   autofocus: boolean
   trapElement: HTMLElement | null
 }
@@ -87,7 +87,7 @@ class FocusTrap extends Config {
   _handleFocusin(event: FocusEvent): void {
     const { trapElement } = this._config
 
-    if (event.target === document || event.target === trapElement || trapElement!.contains(event.target as Node)) {
+    if (!trapElement || event.target === document || event.target === trapElement || trapElement.contains(event.target as Node)) {
       return
     }
 

package/js/src/bootstrap/util/index.ts

@@ -5,12 +5,14 @@
  * --------------------------------------------------------------------------
  */
 
+import type { JQueryPluginStatic, JQueryStaticLike } from '../types'
+
 const MAX_UID = 1_000_000
 const MILLISECONDS_MULTIPLIER = 1000
 const TRANSITION_END = 'transitionend'
 
 const parseSelector = (selector: string): string => {
-  if (selector && window.CSS && window.CSS.escape) {
+  if (selector && typeof CSS !== 'undefined' && typeof CSS.escape === 'function') {
     selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`)
   }
 
@@ -60,7 +62,18 @@ const triggerTransitionEnd = (element: HTMLElement): void => {
   element.dispatchEvent(new Event(TRANSITION_END))
 }
 
+// A jQuery collection stands in for its first element, as in upstream Bootstrap.
+const unwrapJQuery = (object: unknown): unknown => {
+  if (object && typeof object === 'object' && typeof (object as { jquery?: unknown }).jquery !== 'undefined') {
+    return (object as { 0?: unknown })[0]
+  }
+
+  return object
+}
+
 const isElement = (object: unknown): object is HTMLElement => {
+  object = unwrapJQuery(object)
+
   if (!object || typeof object !== 'object') {
     return false
   }
@@ -69,6 +82,8 @@ const isElement = (object: unknown): object is HTMLElement => {
 }
 
 const getElement = (object: unknown): HTMLElement | null => {
+  object = unwrapJQuery(object)
+
   if (isElement(object)) {
     return object
   }
@@ -156,6 +171,48 @@ const reflow = (element: HTMLElement): void => {
 
 const isRTL = (): boolean => document.documentElement.dir === 'rtl'
 
+const getjQuery = (): JQueryStaticLike | null => {
+  if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery') && !document.body.hasAttribute('data-tblr-no-jquery')) {
+    return window.jQuery
+  }
+
+  return null
+}
+
+const DOMContentLoadedCallbacks: Array<() => void> = []
+
+const onDOMContentLoaded = (callback: () => void): void => {
+  if (document.readyState === 'loading') {
+    if (!DOMContentLoadedCallbacks.length) {
+      document.addEventListener('DOMContentLoaded', () => {
+        for (const domCallback of DOMContentLoadedCallbacks) {
+          domCallback()
+        }
+      })
+    }
+
+    DOMContentLoadedCallbacks.push(callback)
+  } else {
+    callback()
+  }
+}
+
+const defineJQueryPlugin = (plugin: JQueryPluginStatic): void => {
+  onDOMContentLoaded(() => {
+    const $ = getjQuery()
+    if ($) {
+      const name = plugin.NAME
+      const JQUERY_NO_CONFLICT = $.fn[name]
+      $.fn[name] = plugin.jQueryInterface
+      $.fn[name].Constructor = plugin
+      $.fn[name].noConflict = () => {
+        $.fn[name] = JQUERY_NO_CONFLICT
+        return plugin.jQueryInterface
+      }
+    }
+  })
+}
+
 const execute = (possibleCallback: unknown, args: unknown[] = [], defaultValue: unknown = possibleCallback): unknown => {
   return typeof possibleCallback === 'function' ? possibleCallback.call(args[0], ...args.slice(1)) : defaultValue
 }
@@ -206,4 +263,4 @@ const getNextActiveElement = <T>(list: T[], activeElement: T, shouldGetNext: boo
   return list[Math.max(0, Math.min(index, listLength - 1))]
 }
 
-export { execute, executeAfterTransition, findShadowRoot, getElement, getNextActiveElement, getTransitionDurationFromElement, getUID, isDisabled, isElement, isRTL, isVisible, noop, parseSelector, reflow, triggerTransitionEnd, toType }
+export { defineJQueryPlugin, execute, executeAfterTransition, findShadowRoot, getElement, getjQuery, getNextActiveElement, getTransitionDurationFromElement, getUID, isDisabled, isElement, isRTL, isVisible, noop, onDOMContentLoaded, parseSelector, reflow, triggerTransitionEnd, toType }

package/js/src/bootstrap/util/swipe.ts

@@ -22,7 +22,7 @@ const POINTER_TYPE_PEN = 'pen'
 const CLASS_NAME_POINTER_EVENT = 'pointer-event'
 const SWIPE_THRESHOLD = 40
 
-interface SwipeConfig {
+type SwipeConfig = {
   endCallback: (() => void) | null
   leftCallback: (() => void) | null
   rightCallback: (() => void) | null
@@ -43,8 +43,8 @@ const DefaultType: ComponentConfigType = {
 class Swipe extends Config {
   declare _config: SwipeConfig & ComponentConfig
   _element: HTMLElement
-  _deltaX: number
-  _supportPointerEvents: boolean
+  declare _deltaX: number
+  declare _supportPointerEvents: boolean
 
   constructor(element: HTMLElement, config?: ComponentConfig) {
     super()

package/js/src/bootstrap/util/template-factory.ts

@@ -13,7 +13,7 @@ import type { AllowList, ComponentConfig, ComponentConfigType, SanitizeFn } from
 
 const NAME = 'TemplateFactory'
 
-interface TemplateFactoryConfig {
+type TemplateFactoryConfig = {
   allowList: AllowList
   content: Record<string, unknown>
   extraClass: string | (() => string)
@@ -104,7 +104,7 @@ class TemplateFactory extends Config {
 
   _typeCheckConfig(config: ComponentConfig): void {
     super._typeCheckConfig(config)
-    this._checkContent(config.content)
+    this._checkContent(config.content as Record<string, unknown>)
   }
 
   _checkContent(arg: Record<string, unknown>): void {