derby/dist/Page.d.ts

MVC framework making it easy to write realtime, collaborative applications that run in both Node.js and browsers.

import { type Model, type RootModel } from 'racer';
import { type App } from './App';
import * as components from './components';
import { Controller } from './Controller';
import { type PageParams } from './routes';
import * as derbyTemplates from './templates';
import { Context } from './templates/contexts';
import { Expression } from './templates/expressions';
export declare abstract class Page extends Controller {
    model: RootModel;
    params: Readonly<PageParams>;
    context: Context;
    create: (model: Model, dom: any) => void;
    init?: (model: Model) => void;
    _components: Record<string, components.Component>;
    _eventModel: any;
    _removeModelListeners: () => void;
    page: Page;
    constructor(app: App, model: Model);
    $bodyClass(ns: string): string;
    get(viewName: string, ns?: string, unescaped?: any): any;
    getFragment(viewName: string, ns?: string): any;
    getView(viewName: string, ns?: string): any;
    destroy(): void;
    render(_ns: string, _status?: number): void;
    _createContext(): derbyTemplates.contexts.Context;
    _setRenderPrefix(ns: string): void;
    _setRenderParams(ns?: string): void;
}
export declare class PageForClient extends Page {
    constructor(app: App, model: Model);
    $preventDefault(e: Event): void;
    $stopPropagation(e: Event): void;
    attach(): void;
    render(ns: string, _status?: number): void;
    private _addListeners;
    private _addModelListeners;
    private _addContextListeners;
}
export declare class BindingWrapper {
    binding: any;
    dependencies: any;
    eventModel: any;
    eventModels: any;
    expression: Expression;
    id: number;
    ignoreTemplateDependency: boolean;
    constructor(eventModel: any, expression: any, binding: any);
    updateDependencies: () => void;
    update: (previous: any, pass: any) => void;
    insert: (index: any, howMany: any) => void;
    remove: (index: any, howMany: any) => void;
    move: (from: any, to: any, howMany: any) => void;
}