@sealcode/sealgen 0.15.33 → 0.15.35

package/src/forms/controls/controls.ts

@@ -29,3 +29,4 @@ export * from "./number.js";
 export * from "./multiple-photos.js";
 // export * from "./reverse-single-reference";
 export * from "./array.js";
+export * from "./table.js";

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>>;
+	}
+}

package/src/utils/utils.ts

@@ -23,3 +23,4 @@ export * from "./make-slug.js";
 export * from "./render-attributes.js";
 export * from "./format-external-url.js";
 export * from "./base64.js";
+export * from "./with-fallback.js";

package/src/utils/with-fallback.ts

@@ -0,0 +1,47 @@
+// use this to more concisely define values with one or more fallbacks to use when they are null.
+
+// If called with two args, the second one has to be non-null
+// if called with three args, the third one has to be non-null
+//
+// in two-arg mode, if the first argument is not null, then it's returned and fallback is not used.
+//                  if the first argument is null, then the second arg is returned
+//
+// in three-arg mode, the first value is never returned. If the first arg is not-null, then the second arg is returned (if it's not null). Otherwise the third arg is returned
+
+export function withFallback<T1, T2 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2
+): NonNullable<T1> | T2;
+export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2,
+	value3?: T3
+): NonNullable<T1> | NonNullable<T2> | T3;
+export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2,
+	value3?: T3
+): NonNullable<T1> | NonNullable<T2> | T3 {
+	if (value3 !== undefined) {
+		// three arg mode
+		if (
+			value1 !== null &&
+			value1 !== undefined &&
+			value2 !== null &&
+			value2 !== undefined
+		) {
+			return value2;
+		} else {
+			return value3;
+		}
+	} else {
+		// two arg mode
+		if (value1 !== null && value1 !== undefined) {
+			return value1;
+		} else if (value2 !== undefined && value2 !== null) {
+			return value2;
+		} else {
+			throw new Error("No suitable fallback: ${arguments}");
+		}
+	}
+}