@glimmer/application-test-helpers/dist/types/src/app-builder.d.ts

Test helpers for developing @glimmer/component and @glimmer/application

import Resolver, { ResolverConfiguration } from '@glimmer/resolver';
import { Dict } from '@glimmer/interfaces';
import Application, { ApplicationConstructor, BytecodeLoader, Loader, INTERNAL_DYNAMIC_SCOPE } from '@glimmer/application';
import { Renderer } from '@glimmer/application';
import { SimpleDocument } from '@simple-dom/interface';
import HTMLSerializer from '@simple-dom/serializer';
export interface AppBuilderOptions<T> {
    appName?: string;
    loader?: string;
    ApplicationClass?: ApplicationConstructor<T>;
    ComponentManager?: any;
    resolverConfiguration?: ResolverConfiguration;
    document?: SimpleDocument;
}
export interface ComponentFactory {
}
export declare class TestApplication extends Application {
    rootElement: Element;
}
export interface AppBuilderTemplateMeta {
    specifier: string;
}
interface HelperFunction extends Function {
    isFactory?: boolean;
}
interface TestSSRApplicationOptions {
    rootName?: string;
    resolver?: Resolver;
    loader?: Loader;
    renderer?: Renderer;
    serializer?: HTMLSerializer;
    [INTERNAL_DYNAMIC_SCOPE]?: Dict<unknown>;
}
export declare class AppBuilder<T extends TestApplication> {
    rootName: string;
    modules: Dict<unknown>;
    templates: Dict<string>;
    options: AppBuilderOptions<T>;
    constructor(name: string, options: AppBuilderOptions<T>);
    template(name: string, template: string): this;
    component(name: string, componentFactory: ComponentFactory): this;
    helper(name: string, helperFunc: HelperFunction, isFactory?: boolean): this;
    protected buildResolver(): Resolver;
    protected buildRuntimeCompilerLoader(): Loader;
    protected buildBytecodeLoader(resolver: Resolver): BytecodeLoader;
    protected buildLoader(resolver: any): Loader;
    renderToString(componentName: string, data: Dict<unknown>, options?: TestSSRApplicationOptions): Promise<string>;
    boot(): Promise<T>;
}
declare function buildApp<T extends TestApplication>(options?: AppBuilderOptions<T>): AppBuilder<T>;
export { buildApp };