@sealcode/sealgen 0.15.34 → 0.15.35

package/src/forms/controls/table.ts

@@ -0,0 +1,78 @@
+import { FlatTemplatable } from "tempstream";
+import { FormField } from "../fields/field.js";
+import { Table as TableField } from "../fields/table.js";
+import { FormControl, FormControlContext } from "./form-control.js";
+
+export class Table<F extends Record<string, FormField>> extends FormControl {
+	role = <const>"input";
+	constructor(
+		public table_field: TableField<F>,
+		public render_fields: {
+			[field_name in keyof F]: (
+				fctx: FormControlContext,
+				name: string,
+				value: string
+			) => string;
+		}
+	) {
+		super();
+	}
+
+	async render(fctx: FormControlContext): Promise<FlatTemplatable> {
+		const { parsed: rows } = await this.table_field.getValue(
+			fctx.ctx,
+			fctx.data
+		);
+		if (!rows) {
+			return "";
+		}
+		return /* HTML */ `<div
+			class="${[
+				"form-input__wrapper",
+				"form-input__wrapper--type--table",
+				"form-input__wrapper--options-count--" + rows.length.toString(),
+				...(rows.length >= 5
+					? ["form-input__wrapper--options-count--5-or-more"]
+					: []),
+				...(rows.length >= 10
+					? ["form-input__wrapper--options-count--10-or-more"]
+					: []),
+				...(rows.length >= 15
+					? ["form-input__wrapper--options-count--15-or-more"]
+					: []),
+				...(rows.length >= 20
+					? ["form-input__wrapper--options-count--20-or-more"]
+					: []),
+			].join(" ")}"
+		>
+			<div class="table__wrapper">
+				<table>
+					<tbody>
+						<tr>
+							${rows
+								?.map((row, row_index) => {
+									return /* HTML */ `<tr>
+										${Object.entries(
+											this.table_field.columns
+										)
+											.map(([key]) => {
+												return `<td>${this.render_fields[
+													key
+												](
+													fctx,
+													`${this.table_field.name}[${row_index}][${key}]`,
+													// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+													row[key] as string
+												)}</td>`;
+											})
+											.join("")}
+									</tr>`;
+								})
+								.join("")}
+						</tr>
+					</tbody>
+				</table>
+			</div>
+		</div>`;
+	}
+}

package/src/forms/fields/fields.ts

@@ -13,3 +13,4 @@ export * from "./file.js";
 export * from "./multiple-files.js";
 export * from "./reverse-single-reference.js";
 export * from "./structured-array.js";
+export * from "./table.js";

package/src/forms/fields/table.ts

@@ -0,0 +1,72 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { Context } from "koa";
+import { FormDataValue } from "../form-types.js";
+import { FieldParseResult, FormField } from "./field.js";
+
+export type TableFieldParsed<F extends Record<string, FormField>> = {
+	[field_name in keyof F]: unknown;
+}[];
+
+export class Table<F extends Record<string, FormField>> extends FormField<
+	true,
+	TableFieldParsed<F>
+> {
+	constructor(public columns: F) {
+		super(true);
+	}
+
+	getEmptyValue() {
+		return [];
+	}
+
+	async parse(
+		ctx: Context,
+		raw_value: FormDataValue
+	): Promise<FieldParseResult<TableFieldParsed<F>>> {
+		// we expect an array-like object: {"0": {...}, ...etc}
+		if (!is(raw_value, predicates.object)) {
+			return {
+				parsable: false,
+				error: "Expected an object",
+				parsed_value: null,
+			};
+		}
+		const result: { [field_name in keyof F]: unknown }[] = [];
+		for (const row_number in raw_value) {
+			const row_data = raw_value[row_number];
+			const parsed_row: Record<string, unknown> = {};
+			if (!is(row_data, predicates.object)) {
+				throw new Error(`Expected object, got ${String(row_data)}`);
+			}
+			for (const key in row_data) {
+				const field = this.columns[key];
+				if (field == undefined) {
+					return {
+						parsable: false,
+						error: `Unknown column: ${key}`,
+						parsed_value: null,
+					};
+				}
+				// eslint-disable-next-line no-await-in-loop, @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+				const parse_result = await field.parse(
+					ctx,
+					(row_data as any)[key]
+				);
+				if (!parse_result.parsable) {
+					console.debug("table.ts:51");
+					return {
+						parsable: false,
+						error: `Invalid value for row ${row_number}.${key}: ${parse_result.error}`,
+						parsed_value: null,
+					};
+				}
+				// eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+				parsed_row[key] = parse_result.parsed_value as any;
+			}
+			// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+			result.push(parsed_row as { [field_name in keyof F]: unknown });
+		}
+		const ret = { parsed_value: result, parsable: true, error: null };
+		return ret as FieldParseResult<TableFieldParsed<F>>;
+	}
+}