Class Application

src/core/application.ts:10–108

import { ActionDescriptorFilter, ActionDescriptorFilters, defaultActionDescriptorFilters } from "./action_descriptor"

export class Application implements ErrorHandler {
  readonly element: Element
  readonly schema: Schema
  readonly dispatcher: Dispatcher
  readonly router: Router
  readonly actionDescriptorFilters: ActionDescriptorFilters
  logger: Logger = console
  debug = false

  static start(element?: Element, schema?: Schema): Application {
    const application = new this(element, schema)
    application.start()
    return application
  }

  constructor(element: Element = document.documentElement, schema: Schema = defaultSchema) {
    this.element = element
    this.schema = schema
    this.dispatcher = new Dispatcher(this)
    this.router = new Router(this)
    this.actionDescriptorFilters = { ...defaultActionDescriptorFilters }
  }

  async start() {
    await domReady()
    this.logDebugActivity("application", "starting")
    this.dispatcher.start()
    this.router.start()
    this.logDebugActivity("application", "start")
  }

  stop() {
    this.logDebugActivity("application", "stopping")
    this.dispatcher.stop()
    this.router.stop()
    this.logDebugActivity("application", "stop")
  }

  register(identifier: string, controllerConstructor: ControllerConstructor) {
    this.load({ identifier, controllerConstructor })
  }

  registerActionOption(name: string, filter: ActionDescriptorFilter) {
    this.actionDescriptorFilters[name] = filter
  }

  load(...definitions: Definition[]): void
  load(definitions: Definition[]): void
  load(head: Definition | Definition[], ...rest: Definition[]) {
    const definitions = Array.isArray(head) ? head : [head, ...rest]
    definitions.forEach((definition) => {
      if ((definition.controllerConstructor as any).shouldLoad) {
        this.router.loadDefinition(definition)
      }
    })
  }

  unload(...identifiers: string[]): void