@sealcode/sealgen 0.3.1 → 0.4.1

package/@types/forms/controls/checkboxed-list-input.d.ts

@@ -1,16 +1,15 @@
 /// <reference types="node" />
 import { BaseContext } from "koa";
-import { FormField } from "../field";
-import { Form, FormData } from "../form";
+import { ChekboxedListField } from "../fields/field";
+import { FormDataValue } from "../form";
 import { FormFieldControl } from "./controls";
 export declare class CheckboxedListInput extends FormFieldControl {
-    fieldname: string;
+    field: ChekboxedListField;
     options: {
         label: string;
     };
-    constructor(fieldname: string, options?: {
+    constructor(field: ChekboxedListField, options?: {
         label: string;
     });
-    isValidFieldName(form: Form): boolean;
-    _render(ctx: BaseContext, fields: FormField[], data: FormData): Promise<import("stream").Readable>;
+    render(ctx: BaseContext, data: Record<string, FormDataValue>): Promise<import("stream").Readable>;
 }

package/@types/forms/controls/dropdown.d.ts

@@ -1,20 +1,19 @@
 /// <reference types="node" />
 import { BaseContext } from "koa";
-import { FormField } from "../field";
-import { FormData } from "../form";
+import { FormField, PickFromListField } from "../fields/field";
+import { FormDataValue } from "../form";
 import { FormFieldControl } from "./controls";
 export declare class Dropdown extends FormFieldControl {
-    fieldname: string;
+    field: PickFromListField;
     options: {
         label: string;
         autosubmit?: boolean;
         autocomplete?: boolean;
     };
-    constructor(fieldname: string, options?: {
+    constructor(field: PickFromListField, options?: {
         label: string;
         autosubmit?: boolean;
         autocomplete?: boolean;
     });
-    areFieldNamesValid(fields: FormField[]): boolean;
-    _render(ctx: BaseContext, fields: FormField[], data: FormData): import("stream").Readable;
+    render<Fields extends Record<string, FormField>>(ctx: BaseContext, data: Record<string, FormDataValue>): Promise<import("stream").Readable>;
 }

package/@types/forms/controls/editable-collection-subset.d.ts

@@ -1,7 +1,7 @@
 import { BaseContext } from "koa";
-import { Templatable } from "tempstream";
-import { FormField } from "../field";
-import { FormData } from "../form";
+import { FlatTemplatable } from "tempstream";
+import { PickFromListField } from "../fields/field";
+import { FormDataValue } from "../form";
 import { FormFieldControl } from "./controls";
 /**
  * This control has own forms in it so if you want to use it you
@@ -11,11 +11,11 @@ import { FormFieldControl } from "./controls";
  * this control for reference.
  */
 export declare class EditableCollectionSubset extends FormFieldControl {
-    fieldname: string;
+    field: PickFromListField;
     actionname: string;
     listLabel?: string | undefined;
     selectLabel?: string | undefined;
-    constructor(fieldname: string, actionname: string, listLabel?: string | undefined, selectLabel?: string | undefined);
-    _render(ctx: BaseContext, fields: FormField[], data: FormData<string>): Templatable | Promise<Templatable>;
+    constructor(field: PickFromListField, actionname: string, listLabel?: string | undefined, selectLabel?: string | undefined);
+    render(ctx: BaseContext, data: Record<string, FormDataValue>): Promise<FlatTemplatable>;
     role: "input";
 }

package/@types/forms/controls/form-control.d.ts

@@ -1,8 +1,7 @@
 import { BaseContext } from "koa";
-import { Templatable } from "tempstream";
-import { FormField } from "../field";
-import { FormData } from "../form";
+import { FlatTemplatable } from "tempstream";
+import { FormDataValue, FormMessage } from "../form";
 export declare abstract class FormControl {
-    abstract render(ctx: BaseContext, formFields: FormField[], data: FormData): Templatable | Promise<Templatable>;
+    abstract render(ctx: BaseContext, data: Record<string, FormDataValue>, messages: FormMessage[]): FlatTemplatable | Promise<FlatTemplatable>;
     abstract role: "input" | "decoration" | "messages" | "submit";
 }

package/@types/forms/controls/form-field-control.d.ts

@@ -1,13 +1,14 @@
 import { BaseContext } from "koa";
-import { Templatable } from "tempstream";
-import { FormField } from "../field";
-import { FormData } from "../form";
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field";
+import { FieldValueType, FormDataValue } from "../form";
 import { FormControl } from "./form-control";
+export declare type FormFieldsToTypes<FormFields extends readonly FormField[]> = {
+    [Index in keyof FormFields]: FormFields[Index] extends FormField ? FieldValueType<FormFields[Index]> : never;
+};
 export declare abstract class FormFieldControl extends FormControl {
-    fieldnames: string[];
+    fields: FormField[];
     role: "input";
-    constructor(fieldnames: string[]);
-    areFieldNamesValid(fields: FormField[]): boolean;
-    abstract _render(ctx: BaseContext, fields: FormField[], data: FormData): Templatable | Promise<Templatable>;
-    render(ctx: BaseContext, fields: FormField[], data: FormData): Templatable | Promise<Templatable>;
+    constructor(fields: FormField[]);
+    abstract render(ctx: BaseContext, data: Record<string, FormDataValue>): FlatTemplatable | Promise<FlatTemplatable>;
 }

package/@types/forms/controls/frame.d.ts

@@ -1,4 +1,4 @@
-import { Templatable } from "tempstream";
+import { FlatTemplatable } from "tempstream";
 import { FormControl } from "./controls";
 /**
  * This class will render `turbo-frame` tag so that u can
@@ -12,6 +12,6 @@ import { FormControl } from "./controls";
 export declare class Frame extends FormControl {
     src: string;
     constructor(src: string);
-    render(): Templatable | Promise<Templatable>;
+    render(): FlatTemplatable | Promise<FlatTemplatable>;
     role: "decoration";
 }

package/@types/forms/controls/simple-input.d.ts

@@ -1,9 +1,9 @@
 import { BaseContext } from "koa";
-import { FormField } from "../field";
-import { FormData } from "../form";
+import { FormField } from "../fields/field";
+import { FormDataValue } from "../form";
 import { FormFieldControl } from "./controls";
 export declare class SimpleInput extends FormFieldControl {
-    fieldname: string;
+    field: FormField;
     options: {
         id?: string;
         label?: string;
@@ -14,7 +14,7 @@ export declare class SimpleInput extends FormFieldControl {
         readonly?: boolean;
         step?: number;
     };
-    constructor(fieldname: string, options?: {
+    constructor(field: FormField, options?: {
         id?: string;
         label?: string;
         autocomplete?: boolean;
@@ -24,5 +24,5 @@ export declare class SimpleInput extends FormFieldControl {
         readonly?: boolean;
         step?: number;
     });
-    _render(_: BaseContext, fields: FormField[], data: FormData): string;
+    render<Fields extends Record<string, FormField>>(ctx: BaseContext, data: Record<string, FormDataValue>): Promise<string>;
 }

package/@types/forms/field.d.ts

@@ -1,42 +1,73 @@
 import { BaseContext } from "koa";
+import { FormDataValue } from "..";
 export declare type FormFieldValidationResponse = {
     valid: boolean;
     message: string;
 };
-export declare type FormFieldValidationFn = (ctx: BaseContext, value: unknown, field: FormField) => Promise<FormFieldValidationResponse>;
-export declare class FormField<Fieldnames extends string = string> {
-    name: Fieldnames;
+export declare type FormFieldValidationFn<ValueType> = (ctx: BaseContext, value: ValueType, field: FormField<ValueType>) => Promise<FormFieldValidationResponse>;
+export declare type FieldParsedValue<T> = T extends FormField<infer R> ? R : never;
+export declare type FieldParseResult<T> = {
+    parsable: false;
+    error: string;
+    parsed_value: null;
+} | {
+    parsable: true;
+    error: null;
+    parsed_value: T;
+};
+export declare abstract class FormField<ParsedValue extends unknown = unknown> {
     required: boolean;
-    validator: FormFieldValidationFn;
-    constructor(name: Fieldnames, required?: boolean, validator?: FormFieldValidationFn);
-    _validate(ctx: BaseContext, value: unknown): Promise<FormFieldValidationResponse>;
+    name: string;
+    constructor(required?: boolean);
+    init(fieldname: string): void;
+    _validate(ctx: BaseContext, value: ParsedValue): Promise<FormFieldValidationResponse>;
+    abstract getEmptyValue(): ParsedValue;
+    isValueValid(ctx: BaseContext, value: ParsedValue): Promise<FormFieldValidationResponse>;
+    abstract parse(raw_value: FormDataValue): Promise<FieldParseResult<ParsedValue>>;
+    getValue(ctx: BaseContext, all_form_values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        message: string;
+        parsed: ParsedValue;
+        raw: FormDataValue;
+    }>;
+}
+export declare class SimpleFormField extends FormField<string> {
+    parse(raw_value: FormDataValue): Promise<FieldParseResult<string>>;
     getEmptyValue(): string;
 }
-export declare class PickFromListField<Fieldnames extends string = string> extends FormField<Fieldnames> {
-    name: Fieldnames;
+export declare class PickFromListField extends SimpleFormField {
     required: boolean;
     generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
         [i: string]: string;
     }>;
     customValidation: (ctx: BaseContext, value: unknown, instance: PickFromListField) => Promise<FormFieldValidationResponse>;
-    constructor(name: Fieldnames, required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+    constructor(required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
         [i: string]: string;
     }>, customValidation?: (ctx: BaseContext, value: unknown, instance: PickFromListField) => Promise<FormFieldValidationResponse>);
+    isValueValid(ctx: BaseContext, value: string): Promise<FormFieldValidationResponse>;
     valueInList(ctx: BaseContext, value: unknown): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): string;
 }
-export declare class ChekboxedListField<Fieldnames extends string = string> extends FormField<Fieldnames> {
-    name: Fieldnames;
+export declare class ChekboxedListField extends FormField<Record<string, "on">> {
     required: boolean;
     generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
         [i: string]: string;
     }>;
     isVisible: (ctx: BaseContext) => Promise<boolean>;
-    constructor(name: Fieldnames, required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+    constructor(required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
         [i: string]: string;
     }>, isVisible?: (ctx: BaseContext) => Promise<boolean>);
-    private isValueValid;
+    isValueValid(_: BaseContext, value: unknown): Promise<FormFieldValidationResponse>;
+    parse(raw_value: FormDataValue): Promise<FieldParseResult<Record<string, "on">>>;
+    getEmptyValue(): Record<string, "on">;
 }
-export declare class NumberField<Fieldnames extends string = string> extends FormField<Fieldnames> {
-    constructor(field_name: Fieldnames, required: boolean);
-    private isValueValid;
+export declare class NumberField<DefaultValue extends number | null = null> extends FormField<number | DefaultValue> {
+    default_value: DefaultValue;
+    constructor(required: boolean | undefined, default_value: DefaultValue);
+    isValueValid(_: BaseContext, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(value: FormDataValue): Promise<FieldParseResult<number>>;
+    getEmptyValue(): DefaultValue;
 }

package/@types/forms/fields/checkboxed-list.d.ts

@@ -0,0 +1,16 @@
+import { BaseContext } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field";
+export declare class ChekboxedListField extends FormField<Record<string, "on">> {
+    required: boolean;
+    generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>;
+    isVisible: (ctx: BaseContext) => Promise<boolean>;
+    constructor(required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>, isVisible?: (ctx: BaseContext) => Promise<boolean>);
+    isValueValid(_: BaseContext, value: unknown): Promise<FormFieldValidationResponse>;
+    parse(_: BaseContext, raw_value: FormDataValue): Promise<FieldParseResult<Record<string, "on">>>;
+    getEmptyValue(): Record<string, "on">;
+}

package/@types/forms/fields/collection-field.d.ts

@@ -0,0 +1,11 @@
+import { BaseContext } from "koa";
+import { Depromisify, Field, FieldOutput } from "sealious";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField, FormFieldValidationResponse } from "./field";
+export declare class CollectionField<F extends Field> extends FormField<FieldOutput<F>> {
+    sealiousField: F;
+    constructor(required: boolean, sealiousField: F);
+    parse(ctx: BaseContext, raw_value: FormDataValue): Promise<FieldParseResult<FieldOutput<F>>>;
+    isValueValid(ctx: BaseContext, value: FieldOutput<F>): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): Depromisify<ReturnType<F["decode"]>>;
+}

package/@types/forms/fields/field.d.ts

@@ -0,0 +1,38 @@
+import { BaseContext } from "koa";
+import { FormDataValue } from "../form";
+export declare type FormFieldValidationResponse = {
+    valid: boolean;
+    message: string;
+};
+export declare type FormFieldValidationFn<ValueType> = (ctx: BaseContext, value: ValueType, field: FormField<ValueType>) => Promise<FormFieldValidationResponse>;
+export declare type FieldParsedValue<T> = T extends FormField<infer R> ? R : never;
+export declare type FieldParseResult<T> = {
+    parsable: false;
+    error: string;
+    parsed_value: null;
+} | {
+    parsable: true;
+    error: null;
+    parsed_value: T;
+};
+export declare abstract class FormField<ParsedValue extends unknown = unknown> {
+    required: boolean;
+    name: string;
+    constructor(required?: boolean);
+    init(fieldname: string): void;
+    _validate(ctx: BaseContext, value: ParsedValue): Promise<FormFieldValidationResponse>;
+    abstract getEmptyValue(): ParsedValue;
+    isValueValid(ctx: BaseContext, value: ParsedValue): Promise<FormFieldValidationResponse>;
+    abstract parse(ctx: BaseContext, raw_value: FormDataValue): Promise<FieldParseResult<ParsedValue>>;
+    getValue(ctx: BaseContext, all_form_values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        message: string;
+        parsed: ParsedValue;
+        raw: FormDataValue;
+    }>;
+}
+export * from "./simple-form-field";
+export * from "./checkboxed-list";
+export * from "./collection-field";
+export * from "./number";
+export * from "./pick-from-list";

package/@types/forms/fields/number.d.ts

@@ -0,0 +1,13 @@
+import { BaseContext } from "koa";
+import { FormDataValue } from "../form";
+import { FieldParseResult, FormField } from "./field";
+export declare class NumberField<DefaultValue extends number | null = null> extends FormField<number | DefaultValue> {
+    default_value: DefaultValue;
+    constructor(required: boolean | undefined, default_value: DefaultValue);
+    isValueValid(_: BaseContext, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: BaseContext, value: FormDataValue): Promise<FieldParseResult<number>>;
+    getEmptyValue(): DefaultValue;
+}

package/@types/forms/fields/pick-from-list.d.ts

@@ -0,0 +1,16 @@
+import { BaseContext } from "koa";
+import { FormFieldValidationResponse } from "./field";
+import { SimpleFormField } from "./simple-form-field";
+export declare class PickFromListField extends SimpleFormField {
+    required: boolean;
+    generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>;
+    customValidation: (ctx: BaseContext, value: unknown, instance: PickFromListField) => Promise<FormFieldValidationResponse>;
+    constructor(required: boolean, generateOptions: (ctx: BaseContext) => Promise<Record<string, string> | {
+        [i: string]: string;
+    }>, customValidation?: (ctx: BaseContext, value: unknown, instance: PickFromListField) => Promise<FormFieldValidationResponse>);
+    isValueValid(ctx: BaseContext, value: string): Promise<FormFieldValidationResponse>;
+    valueInList(ctx: BaseContext, value: unknown): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): string;
+}

package/@types/forms/fields/simple-form-field.d.ts

@@ -0,0 +1,7 @@
+import { FieldParseResult, FormField } from "./field";
+import { FormDataValue } from "../form";
+import { BaseContext } from "koa";
+export declare class SimpleFormField extends FormField<string | null> {
+    parse(_: BaseContext, raw_value: FormDataValue): Promise<FieldParseResult<string>>;
+    getEmptyValue(): string;
+}

package/@types/forms/form-fields-list.d.ts

@@ -1,4 +1,4 @@
 import { FormField } from "./field";
 export declare class FormFieldsList {
-    static getField(fields: FormField[], name: string): FormField<string> | undefined;
+    static getField(fields: FormField[], name: string): any;
 }

package/@types/forms/form.d.ts

@@ -1,22 +1,24 @@
 /// <reference types="koa__router" />
 import { BaseContext } from "koa";
 import Router from "@koa/router";
-import { Templatable } from "tempstream";
-import { FormControl } from "./controls/controls";
-import { Mountable, PageErrorMessage } from "../page/page";
-import { FormField } from "./field";
+import { FlatTemplatable, Templatable } from "tempstream";
+import { FormField } from "./fields/field";
+import { Fields, Mountable, PageErrorMessage } from "../page/mountable";
+export declare type FormDataPrimitive = string | string[] | undefined;
+export declare type FormDataValue = FormDataPrimitive | Record<string, FormDataPrimitive>;
+export declare type FieldValueType<F extends FormField> = F extends FormField<infer R> ? R : never;
+export declare type FormFieldsToValues<F extends Record<string, FormField<keyof F>>> = {
+    [Property in keyof F]: FieldValueType<F[Property]>;
+};
+export declare type FormMessage = {
+    type: "info" | "success" | "error";
+    text: string;
+};
 export declare type FormData<Fieldnames extends string = string> = {
-    values: Record<Fieldnames, string | string[] | number>;
-    raw_values: Record<Fieldnames, string | string[] | number>;
-    errors: Partial<Record<Fieldnames, string>>;
-    messages: {
-        type: "info" | "success" | "error";
-        text: string;
-    }[];
+    raw_values: Record<Fieldnames, FormDataValue>;
+    messages: FormMessage[];
 };
-export declare abstract class Form<Fieldnames extends string = string> implements Mountable {
-    abstract fields: FormField<Fieldnames>[];
-    abstract controls: FormControl[];
+export declare abstract class Form<F extends Fields> extends Mountable<F> {
     defaultSuccessMessage: string;
     submitButtonText: string;
     canAccess(_: BaseContext): Promise<{
@@ -24,19 +26,12 @@ export declare abstract class Form<Fieldnames extends string = string> implement
         message: string;
     }>;
     renderError(_: BaseContext, error: PageErrorMessage): Promise<Templatable>;
-    validate(_: BaseContext, __: Record<string, unknown>): Promise<{
-        valid: boolean;
-        error: string;
-    }>;
-    private _validate;
-    render(ctx: BaseContext, data: FormData, _: string): Promise<Templatable>;
-    renderMessages(_: BaseContext, data: FormData): Templatable;
-    renderControls(ctx: BaseContext, data: FormData): Templatable;
-    makeFormTag(path: string): string;
-    private generateData;
-    onValuesInvalid(ctx: BaseContext, errors: Record<Fieldnames, string>, form_path: string): Promise<void>;
-    onError(ctx: BaseContext, error: unknown, form_path: string): Promise<void>;
-    abstract onSubmit(ctx: BaseContext, values: Record<Fieldnames, string | string[] | number>): void | Promise<void>;
-    onSuccess(ctx: BaseContext, form_path: string): Promise<void>;
+    render(ctx: BaseContext, data: FormData): Promise<Templatable>;
+    makeFormTag(): FlatTemplatable;
+    onValuesInvalid(ctx: BaseContext, form_messages: FormMessage[]): Promise<void>;
+    onError(ctx: BaseContext, data: FormData, error: unknown): Promise<void>;
+    abstract onSubmit(ctx: BaseContext, data: FormData): void | Promise<void>;
+    onSuccess(ctx: BaseContext, data: FormData): Promise<void>;
     mount(router: Router, path: string): void;
+    extractRawValues(ctx: BaseContext): Record<string, FormDataValue>;
 }

package/@types/forms/simple-form-field.d.ts

@@ -0,0 +1,6 @@
+import { FieldParseResult, FormField } from "./field";
+import { FormDataValue } from "./form";
+export declare class SimpleFormField extends FormField<string> {
+    parse(raw_value: FormDataValue): Promise<FieldParseResult<string>>;
+    getEmptyValue(): string;
+}

package/@types/forms/validator.d.ts

@@ -1,3 +0,0 @@
-import { Field } from "sealious";
-import { FormFieldValidationFn } from "./field";
-export declare function collectionFieldValidator(field: Field): FormFieldValidationFn;

package/@types/index.d.ts

@@ -1,14 +1,16 @@
 import Sealious from "sealious";
+import { FormDataValue } from "./forms/form";
 declare module "koa" {
     interface BaseContext {
         $context: Sealious.Context;
-        $body: Record<string, unknown>;
+        $body: Record<string, FormDataValue>;
     }
 }
-export * from "./forms/form";
 export * from "./forms/controls/controls";
-export * from "./forms/field";
+export * from "./forms/fields/field";
+export * from "./page/mountable";
 export * from "./page/page";
+export * from "./forms/form";
 export * from "./page/props-parser";
 export * from "./utils/utils";
-export * from "./forms/validator";
+export * from "./page/list";

package/@types/make-hidden-inputs.d.ts

@@ -0,0 +1,4 @@
+import { BaseContext } from "koa";
+import { Templatable } from "tempstream";
+import { FormDataValue, FormField } from ".";
+export declare function makeHiddenInputs(ctx: BaseContext, fields: Record<string, FormField>, values: Record<string, FormDataValue>, fields_to_skip: string[]): Templatable;

package/@types/page/list.d.ts

@@ -1,57 +1,38 @@
-/// <reference types="node" />
 import { BaseContext } from "koa";
-import { Collection, CollectionItem } from "sealious";
-import { Templatable } from "tempstream";
+import { Collection, CollectionItem, ItemList } from "sealious";
+import { Templatable, FlatTemplatable } from "tempstream";
 import { Page } from "./page";
 import { ShapeToType } from "@sealcode/ts-predicates";
-import { PagePropsParser } from "./props-parser";
 import { FormFieldControl } from "../forms/controls/controls";
-import { FormField } from "../forms/field";
+import { FormField, NumberField } from "../forms/fields/field";
+import { FormDataValue } from "..";
 export declare const BasePagePropsShape: {};
 export declare type BasePageProps = ShapeToType<typeof BasePagePropsShape>;
-export declare const BaseListPagePropsShape: {
-    readonly page: import("@sealcode/ts-predicates").Predicate<number>;
-    readonly itemsPerPage: import("@sealcode/ts-predicates").Predicate<number>;
+export declare const BaseListPageFields: {
+    readonly page: NumberField<1>;
+    readonly itemsPerPage: NumberField<12>;
 };
-export declare type BaseListPageProps = ShapeToType<typeof BaseListPagePropsShape>;
-export declare const BaseListPageDefaultProps: {
-    page: number;
-    itemsPerPage: number;
-};
-export declare type PropsErrors<PropsType> = Partial<Record<keyof PropsType, string>>;
-export declare abstract class ListPage<ItemType, PropsType extends BaseListPageProps = BaseListPageProps> extends Page {
-    abstract getItems(ctx: BaseContext, props: PropsType): Promise<{
-        items: ItemType[];
-    }>;
-    abstract getTotalPages(ctx: BaseContext, props: PropsType): Promise<number>;
-    abstract renderItem(ctx: BaseContext, item: ItemType): Promise<Templatable>;
-    abstract propsParser: PagePropsParser<PropsType>;
-    filterFields: FormField<keyof PropsType>[];
+export declare abstract class ListPage<ItemType, F extends typeof BaseListPageFields> extends Page<F> {
+    abstract getItems(ctx: BaseContext, page: number, itemsPerPage: number, values: Record<string, FormDataValue>): Promise<ItemType[]>;
+    abstract getTotalPages(ctx: BaseContext, itemsPerPage: number, values: Record<string, FormDataValue>): Promise<number>;
+    abstract renderItem(ctx: BaseContext, item: ItemType): Promise<FlatTemplatable>;
+    filterFields: Record<string, FormField>;
     filterControls: FormFieldControl[];
-    renderListContainer(_: BaseContext, content: Templatable): Templatable;
-    validateProps(ctx: BaseContext, props: PropsType): Promise<{
-        valid: boolean;
-        errors: PropsErrors<PropsType>;
-    }>;
-    getProps(ctx: BaseContext): Promise<{
-        parsed_props: PropsType;
-        errors: PropsErrors<PropsType>;
-        raw_props: PropsType;
-    }>;
-    render(ctx: BaseContext): Promise<import("stream").Readable>;
-    renderPagination(ctx: BaseContext, props: PropsType): Promise<import("stream").Readable>;
+    init(): void;
+    renderListContainer(_: BaseContext, content: Templatable): FlatTemplatable;
+    render(ctx: BaseContext): Promise<FlatTemplatable>;
+    renderPagination(ctx: BaseContext, values: Record<string, FormDataValue>): Promise<FlatTemplatable>;
     private renderPageButton;
-    renderFilters(ctx: BaseContext, parsed_props: PropsType, // parsed props don't include wrong values
-    raw_props: PropsType, errors: PropsErrors<PropsType>): import("stream").Readable;
+    getFilterValues(ctx: BaseContext): Promise<Record<string, unknown>>;
+    renderFilters(ctx: BaseContext): FlatTemplatable;
 }
-export declare abstract class SealiousItemListPage<C extends Collection, PageProps extends BaseListPageProps = BaseListPageProps> extends ListPage<CollectionItem<C>, PageProps> {
+export declare abstract class SealiousItemListPage<C extends Collection, F extends typeof BaseListPageFields> extends ListPage<CollectionItem<C>, F> {
     collection: C;
     constructor(collection: C);
-    getTotalPages(ctx: BaseContext, props: PageProps): Promise<number>;
-    getItems(ctx: BaseContext, props: PageProps): Promise<{
-        items: CollectionItem<C>[];
-    }>;
-    renderItem(_: BaseContext, item: CollectionItem<C>): Promise<Templatable>;
+    getTotalPages(ctx: BaseContext, itemsPerPage: number): Promise<number>;
+    protected addFilter(ctx: BaseContext, list: ItemList<C>): Promise<void>;
+    getItems(ctx: BaseContext, page: number, itemsPerPage: number): Promise<CollectionItem<C>[]>;
+    renderItem(_: BaseContext, item: CollectionItem<C>): Promise<FlatTemplatable>;
     canAccess: (ctx: BaseContext) => Promise<{
         canAccess: boolean;
         message: string;

package/@types/page/mountable.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="koa__router" />
+import Router from "@koa/router";
+import { FormControl } from "../forms/controls/form-control";
+import { BaseContext } from "koa";
+import { FlatTemplatable, Templatable } from "tempstream";
+import { FormField } from "../forms/fields/field";
+import { FormData, FormDataValue, FormMessage } from "../forms/form";
+export declare type PageErrorMessage = {
+    type: "access" | "internal";
+    message: string;
+};
+export declare type Fields = Record<string, FormField<unknown>>;
+export declare abstract class Mountable<F extends Fields = Fields> {
+    fields: F;
+    constructor();
+    abstract controls: FormControl[];
+    abstract mount(router: Router, path: string): void;
+    abstract canAccess(ctx: BaseContext): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+    abstract renderError(ctx: BaseContext, error: PageErrorMessage): Promise<Templatable>;
+    abstract extractRawValues(ctx: BaseContext): Record<string, FormDataValue>;
+    validateValues(ctx: BaseContext, data: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        error: string;
+    }>;
+    protected validate(ctx: BaseContext, values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        field_errors: Partial<Record<keyof Fields, string>>;
+        form_messages: FormMessage[];
+    }>;
+    init(): void;
+    renderControls(ctx: BaseContext, data: FormData<keyof Fields>): FlatTemplatable;
+    renderMessages(_: BaseContext, data: FormData<keyof Fields>): Templatable;
+}

package/@types/page/page.d.ts

@@ -1,26 +1,19 @@
 /// <reference types="koa__router" />
-/// <reference types="node" />
 import Router from "@koa/router";
 import { BaseContext } from "koa";
-import { Templatable } from "tempstream";
-export declare type PageErrorMessage = {
-    type: "access" | "internal";
-    message: string;
-};
-export interface Mountable {
-    mount: (router: Router, path: string) => void;
-    canAccess: (ctx: BaseContext) => Promise<{
-        canAccess: boolean;
-        message: string;
-    }>;
-    renderError(ctx: BaseContext, error: PageErrorMessage): Promise<Templatable>;
-}
-export declare abstract class Page implements Mountable {
+import { FlatTemplatable, Templatable } from "tempstream";
+import { FormDataValue } from "../forms/form";
+import { Fields, Mountable, PageErrorMessage } from "./mountable";
+import { PagePropsParser } from "./props-parser";
+export declare abstract class Page<F extends Fields = Record<string, never>> extends Mountable<F> {
+    propsParser: PagePropsParser<Record<keyof Fields, unknown>>;
+    controls: never[];
     mount(router: Router, path: string): void;
     canAccess(_: BaseContext): Promise<{
         canAccess: boolean;
         message: string;
     }>;
-    renderError(_: BaseContext, error: PageErrorMessage): Promise<import("stream").Readable>;
+    renderError(_: BaseContext, error: PageErrorMessage): Promise<FlatTemplatable>;
     abstract render(ctx: BaseContext): Promise<Templatable>;
+    extractRawValues(ctx: BaseContext): Record<string, FormDataValue>;
 }