@sealcode/sealgen 0.19.23 → 0.19.25-hotfix1

package/@types/src/forms/fields/item-draft.d.ts

@@ -0,0 +1,20 @@
+import { Collection, FieldTypes as SealiousFieldTypes } from "sealious";
+import { Hybrid } from "./hybrid.js";
+import { FormField } from "./field.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare class ItemDraft<C extends Collection> extends Hybrid<{
+    [name in keyof C["fields"]]: FormField;
+}> {
+    sealious_field: SealiousFieldTypes.ItemDraft<C>;
+    constructor(sealious_field: SealiousFieldTypes.ItemDraft<C>);
+    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+    generateImportsForFieldList(field_info: ExtractedFieldInfo): {
+        what: string;
+        from: string;
+        as?: string;
+        type?: boolean;
+    }[];
+}

package/@types/src/forms/fields/json.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "koa";
+import { FormControlContext } from "../controls/form-control.js";
+import { Textarea } from "../controls/textarea.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult } from "./field.js";
+import { SimpleFormField } from "./simple-form-field.js";
+export declare class JSONField<Required extends boolean> extends SimpleFormField<Required, Textarea, Record<string, unknown>> {
+    constructor(required: Required);
+    getControl(): Textarea;
+    getEmptyValue(): Record<string, unknown>;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<Record<string, unknown>>>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<Record<string, unknown> | null>;
+}

package/@types/src/forms/fields/markdown.d.ts

@@ -0,0 +1,6 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class Markdown<Required extends boolean> extends TextBasedSimpleField<Required, Textarea> {
+    constructor(required: Required);
+    getControl(): Textarea;
+}

package/@types/src/forms/fields/multiple-files.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "koa";
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormField } from "./field.js";
+import { MultipleFiles as MultipleFilesControl } from "../controls/multiple-files.js";
+export declare class MultipleFiles extends FormField<false, undefined, MultipleFilesControl> {
+    collection_field: SealiousFieldTypes.ReverseSingleReference;
+    getItemId: (ctx: Context) => Promise<string> | string;
+    constructor(collection_field: SealiousFieldTypes.ReverseSingleReference, getItemId: (ctx: Context) => Promise<string> | string);
+    getEmptyValue(): undefined;
+    parse(): Promise<{
+        readonly parsed_value: undefined;
+        readonly parsable: true;
+        readonly error: null;
+    }>;
+    getControl(): MultipleFilesControl;
+}

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

@@ -0,0 +1,25 @@
+import { Context } from "koa";
+import { SimpleInput } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+export declare class NumberField<DefaultValue extends number | null = number, Required extends boolean = boolean> extends FormField<Required, number | DefaultValue, SimpleInput> {
+    default_value: DefaultValue;
+    options: Partial<{
+        max: number;
+        min: number;
+        decimalDigits: number;
+    }>;
+    constructor(required: Required, default_value: DefaultValue, options?: Partial<{
+        max: number;
+        min: number;
+        decimalDigits: number;
+    }>);
+    predicate: import("@sealcode/ts-predicates").Predicate<number>;
+    isValueValid(_: Context, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<number>>;
+    getEmptyValue(): DefaultValue;
+    getControl(): SimpleInput;
+}

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

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/password.d.ts

@@ -0,0 +1,10 @@
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class Password<Required extends boolean> extends TextBasedSimpleField<Required> {
+    constructor(required: Required);
+    sealiousValueToForm(): Promise<undefined>;
+    generateInitialValue(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        form_fields: string;
+    }): string;
+}

package/@types/src/forms/fields/phone-number-with-country-code.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "koa";
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormControl } from "../controls/controls.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+import { FormControlContext } from "../../index.js";
+export declare class PhoneNumberWithCountryCode<Required extends boolean> extends FormField<Required, SealiousFieldTypes.PhoneNumberValue> {
+    getEmptyValue(): SealiousFieldTypes.PhoneNumberValue;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<SealiousFieldTypes.PhoneNumberValue>>;
+    getControl(): FormControl;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string>;
+    sealiousValueToForm(ctx: Context, sealiousValue: SealiousFieldTypes.PhoneNumberValue | null): Promise<FormDataValue>;
+}

package/@types/src/forms/fields/phone-number.d.ts

@@ -0,0 +1,17 @@
+import { Context } from "koa";
+import { FormControl } from "../controls/controls.js";
+import { FormDataValue } from "../form-types.js";
+import { FormField } from "./field.js";
+export declare class PhoneNumberWithoutCountryCode<Required extends boolean> extends FormField<Required, string> {
+    getEmptyValue(): string;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<{
+        parsable: true;
+        parsed_value: string;
+        error: null;
+    } | {
+        parsable: false;
+        parsed_value: null;
+        error: string;
+    }>;
+    getControl(): FormControl;
+}

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

@@ -0,0 +1,11 @@
+import { FieldTypes as SealiousFieldTypes } from "sealious";
+import { PickFromListField } from "./pick-from-list.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare class PickFromListSealious<Required extends boolean> extends PickFromListField<Required> {
+    sealious_field: SealiousFieldTypes.Enum<string>;
+    constructor(sealious_field: SealiousFieldTypes.Enum<string>);
+    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+}

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

@@ -0,0 +1,15 @@
+import { Context } from "koa";
+import { Dropdown, DropdownOption } from "../controls/dropdown.js";
+import { FormFieldValidationResponse } from "./field.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class PickFromListField<Required extends boolean> extends TextBasedSimpleField<Required, Dropdown> {
+    required: Required;
+    generateOptions: (ctx: Context) => Promise<DropdownOption[]>;
+    customValidation: (ctx: Context, value: unknown, instance: PickFromListField<Required>) => Promise<FormFieldValidationResponse>;
+    constructor(required: Required, generateOptions: (ctx: Context) => Promise<DropdownOption[]>, customValidation?: (ctx: Context, value: unknown, instance: PickFromListField<Required>) => Promise<FormFieldValidationResponse>);
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    isValueValid(ctx: Context, value: string): Promise<FormFieldValidationResponse>;
+    valueInList(ctx: Context, value: unknown): Promise<FormFieldValidationResponse>;
+    getEmptyValue(): string;
+    getControl(): Dropdown;
+}

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

@@ -0,0 +1 @@
+export {};

package/@types/src/forms/fields/proxy-field.d.ts

@@ -0,0 +1,15 @@
+import { FormControl } from "../controls/form-control.js";
+import { FormField } from "./field.js";
+export declare class ProxyFormField<T> extends FormField<boolean, T, any> {
+    name: string;
+    empty_value: T;
+    parsed_value: T;
+    constructor(required: boolean, name: string, empty_value: T, parsed_value: T);
+    getEmptyValue(): T;
+    parse(): Promise<{
+        readonly parsable: true;
+        readonly error: null;
+        readonly parsed_value: T;
+    }>;
+    getControl(): FormControl;
+}

package/@types/src/forms/fields/regexp.d.ts

@@ -0,0 +1,21 @@
+import { Context } from "koa";
+import { SimpleInput } from "../controls/simple-input.js";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+import { FormControlContext } from "../controls/form-control.js";
+export declare class RegExpField<Required extends boolean> extends FormField<Required, string, SimpleInput, string> {
+    regexp: RegExp;
+    error_message: string;
+    default_value: string;
+    constructor(required: Required, regexp: RegExp, error_message: string, default_value?: string);
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    isValueValid(_: Context, value: unknown): Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+    parse(_: Context, value: FormDataValue): Promise<FieldParseResult<string>>;
+    getEmptyValue(): string;
+    getControl(): SimpleInput;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string>;
+    sealiousValueToForm(ctx: Context, sealious_value: string | null): Promise<FormDataValue>;
+}

package/@types/src/forms/fields/regexp.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+import { FormData, FormDataValue } from "../form-types.js";
+import { Context } from "koa";
+import { FieldParseResult, FormField } from "./field.js";
+import { SimpleInput } from "../controls/simple-input.js";
+import { FormControl } from "../controls/controls.js";
+import { CollectionItem } from "sealious";
+import { FormControlContext } from "../controls/form-control.js";
+export declare abstract class SimpleFormField<Required extends boolean, DefaultControl extends FormControl = SimpleInput, Parsed = string> extends FormField<Required, Parsed, DefaultControl> {
+    type: string;
+    predicate: import("@sealcode/ts-predicates").Predicate<string>;
+    placeholder: string;
+    constructor(required: Required, type?: string);
+    sealiousValueToForm(_ctx: Context, value: unknown): Promise<FormDataValue>;
+    setPlaceholder(placeholder: string): this;
+}
+export declare class TextBasedSimpleField<Required extends boolean, DefaultControl extends FormControl = SimpleInput> extends SimpleFormField<Required, DefaultControl, string | null> {
+    parse(_: Context, raw_value: FormDataValue): Promise<FieldParseResult<string>>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string | null>;
+    postSealiousCreate(_ctx: Context, _created_item: CollectionItem<any>, _formData: FormData): Promise<void>;
+    postSealiousEdit(ctx: Context, _edited_item: CollectionItem<any>, _formData: FormData): Promise<void>;
+    getControl(): DefaultControl;
+    getEmptyValue(): string;
+}
+export declare class NumberBasedSimpleField<Required extends boolean, DefaultControl extends FormControl = SimpleInput> extends SimpleFormField<Required, DefaultControl, number> {
+    parse(_: Context, raw_value: FormDataValue): Promise<FieldParseResult<number>>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<number | undefined>;
+    postSealiousCreate(): Promise<void>;
+    postSealiousEdit(): Promise<void>;
+    getControl(): DefaultControl;
+    getEmptyValue(): number;
+}

package/@types/src/forms/fields/single-reference.d.ts

@@ -0,0 +1,19 @@
+import { Collection, FieldTypes as SealiousFieldTypes } from "sealious";
+import { CollectionField } from "./collection-field.js";
+import { SingleReferenceDropdown } from "../controls/single-reference.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { Context } from "koa";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+export declare class SingleReference<TargetCollection extends Collection, Required extends boolean, F extends SealiousFieldTypes.SingleReference> extends CollectionField<F, Required> {
+    getControl(): SingleReferenceDropdown<TargetCollection, F, Required>;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string | undefined>;
+    sealiousValueToForm(_ctx: Context, value: string | null): Promise<string | undefined>;
+    generateImportsForFieldList(field_info: ExtractedFieldInfo): {
+        what: string;
+        from: string;
+    }[];
+    generateFieldDeclaration(field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+}

package/@types/src/forms/fields/structured-array.d.ts

@@ -0,0 +1,23 @@
+import { Context } from "koa";
+import { Field as SealiousField, FieldTypes as SealiousFieldTypes } from "sealious";
+import { FormDataValue } from "../form-types.js";
+import { Table as TableControl } from "../controls/table.js";
+import { SealiousToFormField } from "./get-field-for-sealious.js";
+import { FormControlContext } from "../controls/form-control.js";
+import { ExtractedFieldInfo } from "../../utils/extract-fields-from-collection.js";
+import { Table } from "./table.js";
+export declare class StructuredArray<SealiousFields extends Record<string, SealiousField<unknown>>> extends Table<{
+    [name in keyof SealiousFields]: SealiousToFormField<SealiousFields[name]>;
+}> {
+    sealious_field: SealiousFieldTypes.StructuredArray<SealiousFields>;
+    constructor(sealious_field: SealiousFieldTypes.StructuredArray<SealiousFields>);
+    getControl(): TableControl<{
+        [name in keyof SealiousFields]: SealiousToFormField<SealiousFields[name]>;
+    }>;
+    generateFieldDeclaration(_field_info: ExtractedFieldInfo, vars: {
+        form_field_types: string;
+        sealious_field: string;
+    }): string;
+    getSealiousCreateValue(fctx: FormControlContext): Promise<import("./table.js").TableFieldParsed<{ [name in keyof SealiousFields]: SealiousToFormField<SealiousFields[name]>; }>>;
+    sealiousValueToForm(ctx: Context, sealiousValue: Record<string, FormDataValue | null>[] | null): Promise<FormDataValue>;
+}

package/@types/src/forms/fields/table.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+import { Table as TableControl } from "../controls/table.js";
+export type ExtractFormFieldParsed<Field extends FormField> = Field extends FormField<true, infer T> ? NonNullable<T> : Field extends FormField<true, infer T> ? T : never;
+export type TableFieldParsed<F extends Record<string, FormField>> = {
+    [field_name in keyof F]: ExtractFormFieldParsed<F[field_name]>;
+}[];
+export declare class Table<F extends Record<string, FormField>> extends FormField<false, TableFieldParsed<F>> {
+    columns: F;
+    constructor(columns: F);
+    getEmptyValue(): never[];
+    setName(name: string): this;
+    parse(ctx: Context, raw_value: FormDataValue): Promise<FieldParseResult<TableFieldParsed<F>>>;
+    getControl(): TableControl<F>;
+}

package/@types/src/forms/fields/text.d.ts

@@ -0,0 +1,6 @@
+import { FormControlContext } from "../controls/form-control.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class Text<Required extends boolean> extends TextBasedSimpleField<Required> {
+    constructor(required: Required);
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string>;
+}

package/@types/src/forms/fields/url.d.ts

@@ -0,0 +1,6 @@
+import { FormControlContext } from "../controls/form-control.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+export declare class URLField<Required extends boolean> extends TextBasedSimpleField<Required> {
+    constructor(required: Required);
+    getSealiousCreateValue(fctx: FormControlContext): Promise<string | null>;
+}

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

@@ -0,0 +1,28 @@
+import { FilePointer } from "@sealcode/file-manager";
+import type { FlatTemplatable } from "tempstream";
+import type { FormField } from "./fields/field.js";
+import { FieldMessages } from "./controls/form-control.js";
+export type FormDataPrimitive = string | string[] | number | undefined | FilePointer;
+export type FormDataValue = FormDataPrimitive | Record<string, FormDataPrimitive>;
+export type FieldValueType<F extends FormField> = F extends FormField<infer R> ? R : never;
+export type FormFieldsToValues<F extends Record<string, FormField<boolean, keyof F>>> = {
+    [Property in keyof F]: FieldValueType<F[Property]>;
+};
+export type FormMessage = {
+    type: "info" | "success" | "error";
+    text: string;
+};
+export type FormData<Fieldnames extends string = string> = {
+    raw_values: Record<Fieldnames, FormDataValue>;
+    messages: FormMessage[];
+    field_messages: FieldMessages<Fieldnames>;
+};
+export type FormReaction = {
+    action: "stay";
+    content: FlatTemplatable;
+    messages?: FormMessage[];
+} | {
+    action: "redirect";
+    url: string;
+    messages?: FormMessage[];
+};

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

@@ -0,0 +1,34 @@
+import { Context } from "koa";
+import Router from "@koa/router";
+import { FormData, FormDataValue, FormMessage, FormReaction } from "./form-types.js";
+import { Fields, MountableWithFields, PageErrorMessage } from "../page/mountable-with-fields.js";
+import { Readable } from "stream";
+import { FormField } from "../index.js";
+import { FieldMessages } from "./controls/form-control.js";
+export declare abstract class Form<F extends Fields, SubmitResult> extends MountableWithFields<F> {
+    defaultSuccessMessage: string;
+    submitButtonText: string;
+    action: string;
+    useTurbo: boolean;
+    form_id: string;
+    canAccess(_: Context): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+    renderError(_: Context, error: PageErrorMessage): Promise<JSX.Element | Readable>;
+    makeSubmitButton(): JSX.Element;
+    render(ctx: Context, data: FormData, show_field_errors: boolean): Promise<JSX.Element | Readable>;
+    makeFormClasses(_ctx: Context): Promise<string[]>;
+    makeOpenFormTag(ctx: Context): JSX.Element;
+    makeCloseFormTag(): JSX.Element;
+    onValuesInvalid(ctx: Context, form_messages: FormMessage[], field_errors: FieldMessages<keyof Fields>): Promise<FormReaction>;
+    onError(ctx: Context, data: FormData, error: unknown): Promise<FormReaction>;
+    abstract onSubmit(ctx: Context, data: FormData): SubmitResult | Promise<SubmitResult>;
+    onSuccess(ctx: Context, _data: FormData, _submitResult: SubmitResult): Promise<FormReaction>;
+    getRawValuesOnSuccess(ctx: Context): Promise<Record<string, FormDataValue>>;
+    handlePost(ctx: Context): Promise<FormReaction>;
+    init(path: string, router: Router): void;
+    mount(router: Router, path: string): void;
+    extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
+    static initFieldNames(fields: Record<string, FormField>): void;
+}

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

@@ -0,0 +1,6 @@
+import { Controls, Fields, Form, Mountable } from "../index.js";
+declare const fields: {
+    text: Fields.TextBasedSimpleField<true, Controls.SimpleInput<import("./controls/simple-input.js").SimpleInputOptions>>;
+};
+export declare function form_factory(canAccessFun?: Mountable["canAccess"]): Form<typeof fields, void>;
+export {};

package/@types/src/forms/multiform.d.ts

@@ -0,0 +1,23 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { Fields, MountableWithFields } from "../page/mountable-with-fields.js";
+import type { FormDataValue, FormMessage } from "./form-types.js";
+import { Form } from "./form.js";
+export declare class Multiform extends MountableWithFields {
+    getControls: () => never[];
+    name: string;
+    forms: Record<string, Form<Fields, unknown>>;
+    init(path: string, router: Router): void;
+    extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
+    canAccess(): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+    getSubformsToRender(ctx: Context): Array<readonly [string, Form<any, unknown>]>;
+    renderSubform(ctx: Context, sub_form_name: string, show_field_errors: boolean): Promise<FlatTemplatable>;
+    getSubformRawValues(ctx: Context, sub_form_name: string): Promise<Record<string, FormDataValue>>;
+    render(ctx: Context, messages: FormMessage[], prerenderedForms: Record<string, FlatTemplatable | undefined> | undefined, show_field_errors: boolean): Promise<FlatTemplatable>;
+    makeBottomScript(): string;
+    mount(router: Router, path: string): void;
+}

package/@types/src/forms/multiform.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/generate-collections.d.ts

@@ -0,0 +1,2 @@
+export declare function extractCollectionClassname(full_file_path: string): Promise<string>;
+export declare function generateCollections(): Promise<void>;

package/@types/src/generate-components.d.ts

@@ -0,0 +1 @@
+export declare function generateComponents(): Promise<void>;

package/@types/src/generate-routes.d.ts

@@ -0,0 +1,5 @@
+export declare function generateURL(actionName: string, url: string): string;
+export declare function sortRoutes<T extends {
+    url: string;
+}>(urls: T[]): T[];
+export declare function generateRoutes(): Promise<void>;

package/@types/src/generate-routes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/@types/src/generate-stimulus.d.ts

@@ -0,0 +1 @@
+export declare function generateStimulusControllers(controller_dirs: string[]): Promise<void>;

package/@types/src/get-fonts.d.ts

@@ -0,0 +1,2 @@
+export declare const FONTS_CONFIG_PATH = "src/fonts.json";
+export declare function getFonts(_?: Record<string, string | boolean>): Promise<void>;

package/@types/{index.d.sync-conflict-20260502-145557-GP5D735.ts → src/index.d.ts}

@@ -45,3 +45,4 @@ export interface HTMLArgs {
     hideNavigation?: boolean;
 }
 export type HTMLFunc = (args: HTMLArgs) => Readable | Promise<Readable>;
+export type BreadcrumbLabel = string | ((ctx: Context) => Promise<string>);

package/@types/src/make-env.d.ts

@@ -0,0 +1 @@
+export declare function makeEnv(): Promise<void>;

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

@@ -0,0 +1,5 @@
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "./forms/fields/field.js";
+import { FormDataValue } from "./forms/form-types.js";
+export declare function makeHiddenInputs(ctx: Context, fields: Record<string, FormField>, values: Record<string, FormDataValue>, fields_to_skip: string[]): FlatTemplatable;

package/@types/src/mount.d.ts

@@ -0,0 +1,6 @@
+import Router from "@koa/router";
+import { FileManager } from "@sealcode/file-manager";
+import { Mountable } from "./page/mountable.js";
+export declare function mount(router: Router, url: string | {
+    rawURL: string;
+}, mountable: Mountable, use_dummy_app?: boolean, file_manager?: FileManager | undefined): void;

package/@types/src/notifier.d.ts

@@ -0,0 +1,2 @@
+export declare const APP_BACK_ALIVE_SIGNAL = "app-back-alive";
+export declare function make_notifier(port: number, app_port: number): (message: string) => void;

package/@types/src/page/access-control.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "koa";
+import { ActionName, Collection } from "sealious";
+export declare function peopleWhoCan(action: ActionName, collection: Collection): (ctx: Context) => Promise<{
+    canAccess: boolean;
+    message: string;
+}>;

package/@types/src/page/default-list-filters.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "koa";
+import { Field } from "sealious";
+import { FlatTemplatable } from "tempstream";
+export type ListFilterRender = (value: string, field: Field<any>, ctx: Context) => FlatTemplatable;
+export type DefaultListFilter = {
+    render: ListFilterRender;
+    prepareValue?: (filter_value: unknown) => unknown;
+};
+export declare const BooleanListFilter: {
+    render: (value: string, field: Field<any>) => string;
+};
+export declare const SimpleTextFilter: {
+    render: (value: string, field: Field<any>) => string;
+    prepareValue: (value: string) => {
+        regex: string;
+    };
+};
+export declare const DefaultListFilters: Record<"boolean" | "text" | "fallback", DefaultListFilter>;

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

@@ -0,0 +1,49 @@
+import { ShapeToType } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FlatTemplatable, Templatable } from "tempstream";
+import { FormControl } from "../forms/controls/controls.js";
+import { FormField } from "../forms/fields/field.js";
+import { NumberField } from "../forms/fields/number.js";
+import { TextBasedSimpleField } from "../forms/fields/simple-form-field.js";
+import { FormDataValue } from "../forms/form-types.js";
+import { Page } from "./page.js";
+import Router from "@koa/router";
+export declare const BasePagePropsShape: {};
+export type BasePageProps = ShapeToType<typeof BasePagePropsShape>;
+export declare const DEFAULT_ITEMS_PER_PAGE = 12;
+export declare const BaseListPageFields: {
+    readonly page: NumberField<1, false>;
+    readonly itemsPerPage: NumberField<12, false>;
+    readonly sort: TextBasedSimpleField<false, import("../forms/controls/simple-input.js").SimpleInput<import("../forms/controls/simple-input.js").SimpleInputOptions>>;
+};
+export type ListSort = {
+    field: string;
+    order: "asc" | "desc";
+};
+export declare abstract class ListPage<ItemType, F extends typeof BaseListPageFields> extends Page<F> {
+    abstract getItems(ctx: Context, page: number, itemsPerPage: number | null, values: Record<string, FormDataValue>): Promise<ItemType[]>;
+    abstract getTotalPages(ctx: Context, itemsPerPage: number, values: Record<string, FormDataValue>): Promise<number>;
+    abstract renderItem(ctx: Context, item: ItemType, index: number): Promise<FlatTemplatable>;
+    filterFields: Record<string, FormField>;
+    filterControls: FormControl[];
+    init(path: string, router: Router): void;
+    renderListContainer(_: Context, content: Templatable): FlatTemplatable;
+    getPaginationConfig(ctx: Context): Promise<{
+        page: number;
+        itemsPerPage: number | null;
+    }>;
+    renderItems(ctx: Context, values?: Record<string, FormDataValue>, items?: ItemType[]): Promise<FlatTemplatable>;
+    renderPagination(ctx: Context, values: Record<string, FormDataValue>): Promise<FlatTemplatable>;
+    private renderPageButton;
+    getFilterValues(ctx: Context): Promise<Record<string, unknown>>;
+    getSort(ctx: Context): Promise<ListSort | null>;
+    makeSortLink(ctx: Context, field: string, order: "asc" | "desc" | null): string;
+    renderFilters(ctx: Context): Promise<FlatTemplatable>;
+    renderHeading(ctx: Context, field: string, label?: string): Promise<FlatTemplatable>;
+    getDefaultSort(_: Context): ListSort | null;
+    renderTableHead(ctx: Context, fields: {
+        field: string;
+        label?: string;
+    }[]): FlatTemplatable;
+    render(ctx: Context): Promise<FlatTemplatable>;
+}

package/@types/src/page/mountable-with-fields.d.ts

@@ -0,0 +1,49 @@
+import { ShapeToType } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FlatTemplatable } from "tempstream";
+import { FieldMessages, FormControl, FormControlContext } from "../forms/controls/form-control.js";
+import type { FieldsToShape, FormField } from "../forms/fields/field.js";
+import type { FormDataValue, FormMessage, FormData } from "../forms/form-types.js";
+import { Mountable } from "./mountable.js";
+import Router from "@koa/router";
+export type PageErrorMessage = {
+    type: "access" | "internal";
+    message: string;
+};
+export type Fields = Record<string, FormField<boolean, any>>;
+type Resolved<T> = T extends Promise<infer X> ? X : never;
+type ParsedValue<T extends FormField> = Resolved<ReturnType<T["getParsedValue"]>>["parsed"];
+export declare abstract class MountableWithFields<F extends Fields = Fields> extends Mountable {
+    getFields: () => F;
+    fields: F;
+    initialized: boolean;
+    field_names_prefix: string;
+    form_id: string;
+    abstract getControls: (fields: F) => FormControl[];
+    controls: FormControl[];
+    constructor();
+    /** most routes should be setup using .mount(), but mount runs before
+        initialization so we don't yet have controls, app, etc ready for dynamic
+        routes **/
+    init(path: string, router: Router): void;
+    makeFormControlContext(ctx: Context, data: FormData, validate: boolean, field_name_prefix?: string, form_id?: string): FormControlContext;
+    validateValues(_ctx: Context, _data: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        error: string;
+    }>;
+    getInitialValues(_ctx: Context): Promise<Record<string, FormDataValue>>;
+    validate(ctx: Context, values: Record<string, FormDataValue>): Promise<{
+        valid: boolean;
+        field_errors: FieldMessages;
+        form_messages: FormMessage[];
+    }>;
+    renderControls(fctx: FormControlContext): FlatTemplatable;
+    renderError(_: Context, error: PageErrorMessage): Promise<FlatTemplatable>;
+    renderMessages(_: Context, data: FormData<keyof Fields>): FlatTemplatable;
+    abstract extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
+    getParsedValues(ctx: Context): Promise<{
+        [field in keyof F]: F[field] extends FormField<true> ? Exclude<ParsedValue<F[field]>, null> : ParsedValue<F[field]>;
+    }>;
+    getDatabaseValues(ctx: Context): Promise<ShapeToType<FieldsToShape<F>>>;
+}
+export {};

package/@types/src/page/mountable-with-fields.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import Router from "@koa/router";
+import { Context } from "koa";
+export declare abstract class Mountable {
+    init(_path: string, _router: Router): void;
+    abstract mount(router: Router, path: string): void;
+    abstract canAccess(ctx: Context): Promise<{
+        canAccess: boolean;
+        message: string;
+    }>;
+}