@sealcode/sealgen 0.8.44 → 0.8.48

package/src/forms/controls/simple-input.ts

@@ -1,148 +0,0 @@
-import { Context } from "koa";
-import { FlatTemplatable, tempstream } from "tempstream";
-import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper";
-import { renderAttributes } from "../../utils/render-attributes";
-import { FormField } from "../fields/field";
-import { FormDataValue } from "../form";
-import { FormFieldControl } from "./controls";
-import { FormControlContext } from "./form-control";
-
-export type SimpleInputOptions = {
-	id?: string;
-	label?: string;
-	autocomplete?: boolean;
-	hide_errors?: boolean;
-	type?:
-		| "color"
-		| "date"
-		| "email"
-		| "file"
-		| "month"
-		| "number"
-		| "password"
-		| "search"
-		| "tel"
-		| "text"
-		| "time"
-		| "url"
-		| "week";
-	value?: string;
-	placeholder?: string;
-	readonly?: boolean;
-	step?: number;
-	suffix?: string;
-};
-
-export class SimpleInput<
-	ParsedValue,
-	Options extends SimpleInputOptions = SimpleInputOptions
-> extends FormFieldControl {
-	options: SimpleInputOptions;
-	constructor(
-		public field: FormField<boolean, ParsedValue>,
-		options?: Options
-	) {
-		super([field]);
-		this.options = options || {};
-	}
-
-	async preInput(
-		_ctx: Context,
-		_data: Record<string, FormDataValue>
-	): Promise<FlatTemplatable> {
-		return "";
-	}
-
-	getType(): string {
-		return this.options.type || "text";
-	}
-
-	getLabel(): string {
-		return this.options.label != undefined
-			? this.options.label
-			: this.field.name;
-	}
-
-	getID(): string {
-		return this.options.id || this.field.name;
-	}
-
-	getPlaceholder(): string {
-		return this.options.placeholder === ""
-			? ""
-			: this.options.placeholder || this.getType();
-	}
-
-	async getInputAttributes(
-		fctx: FormControlContext
-	): Promise<Record<string, string | boolean>> {
-		const readonly = this.options.readonly || false;
-		const required = this.field.required;
-		const { parsed, raw, valid } = await this.field.getValue(
-			fctx.ctx,
-			fctx.data
-		);
-		return Object.fromEntries([
-			<const>["id", this.getID()],
-			<const>["type", this.getType()],
-			<const>["name", `${fctx.field_name_prefix}${this.field.name}`],
-			<const>[
-				"value",
-				!valid && raw
-					? raw.toString()
-					: parsed !== undefined && parsed !== null
-					? ((parsed as any)?.toString() as string) || ""
-					: "",
-			],
-			...(fctx.form_id ? [["form", fctx.form_id]] : []),
-			<const>["placeholder", this.getPlaceholder()],
-			...(readonly ? [["readonly", true]] : []),
-			...(required ? [["required", true]] : []),
-			...(!this.options.autocomplete ? [["autocomplete", "off"]] : []),
-			...(this.options.step ? [["step", this.options.step]] : []),
-		]);
-	}
-
-	async postInput(_: Context): Promise<FlatTemplatable> {
-		return this.options.suffix
-			? /* HTML */ `<span class="suffix">${this.options.suffix}</span>`
-			: "";
-	}
-
-	async renderInput(
-		_ctx: Context,
-		attributes_str: string,
-		_data: Record<string, FormDataValue>
-	): Promise<FlatTemplatable> {
-		return `<input ${attributes_str} />`;
-	}
-
-	async render<Fields extends Record<string, FormField>>(
-		fctx: FormControlContext
-	): Promise<FlatTemplatable> {
-		const id = this.getID();
-		const label = this.getLabel();
-		const type = this.getType();
-
-		const { valid, message } = await this.field.getValue(
-			fctx.ctx,
-			fctx.data
-		);
-		return inputWrapper(
-			[id, type, getRequiredClass(this.field.required)],
-			tempstream/* HTML */ `
-				${label ? `<label for="${id}">${label}</label>` : ""}
-				${await this.preInput(fctx.ctx, fctx.data)}
-				${this.renderInput(
-					fctx.ctx,
-					renderAttributes(await this.getInputAttributes(fctx)),
-					fctx.data
-				)}
-				${this.postInput(fctx.ctx)}
-				${~valid && !this.options.hide_errors && fctx.validate
-					? `<div class="input__error">${message}</div>`
-					: ""}
-			`
-		);
-	}
-}

package/src/forms/controls/textarea.ts

@@ -1,60 +0,0 @@
-import { Context } from "koa";
-import { FormField } from "../fields/field";
-import { FormDataValue } from "../form";
-import { FormControlContext } from "./form-control";
-import { SimpleInput, SimpleInputOptions } from "./simple-input";
-
-export class Textarea<Required extends boolean> extends SimpleInput<
-	string | null
-> {
-	constructor(
-		public field: FormField<boolean, string | null>,
-		public options: SimpleInputOptions & {
-			label?: string;
-			rows?: number;
-			cols?: number;
-			description?: string;
-			autogrow?: boolean;
-		} = {}
-	) {
-		super(field, options);
-	}
-
-	renderDescription() {
-		return this.options.description
-			? /* HTML */ `<div class="form-input__description">
-					${this.options.description}
-			  </div>`
-			: "";
-	}
-
-	async getInputAttributes(
-		fctx: FormControlContext
-	): Promise<Record<string, string | boolean>> {
-		const original = (await super.getInputAttributes(fctx)) as Record<
-			string,
-			string | boolean
-		>;
-		let onkeydown = original.onkeydown || "";
-		if (this.options.autogrow) {
-			onkeydown += `;this.style.height = '5px';this.style.height = Math.max((this.scrollHeight)+32, ${
-				((this.options.rows || 2) + 1) * 16
-			} )+'px';`;
-		}
-		return {
-			...original,
-			rows: this.options.rows ? this.options.rows.toString() : false,
-			cols: this.options.cols ? this.options.cols.toString() : false,
-			onkeydown,
-		};
-	}
-
-	async renderInput(
-		ctx: Context,
-		attributes: string,
-		data: Record<string, FormDataValue>
-	) {
-		const { parsed: value } = await this.field.getValue(ctx, data);
-		return /* HTML */ `<textarea ${attributes}>${value}</textarea>`;
-	}
-}

package/src/forms/controls/tickable.ts

@@ -1,127 +0,0 @@
-import { Context } from "koa";
-import { FlatTemplatable } from "tempstream";
-import { attribute } from "../../sanitize";
-import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper";
-import { FormField } from "../fields/field";
-import { FormDataValue } from "../form";
-import { FormFieldControl } from "./controls";
-import { FormControlContext } from "./form-control";
-
-export type TickableOptions = {
-	id?: string;
-	name?: string;
-	label?: string;
-	hide_errors?: boolean;
-	readonly?: boolean;
-};
-
-export abstract class Tickable<T extends unknown> extends FormFieldControl {
-	constructor(
-		public field: FormField<boolean, T>,
-		public options: TickableOptions = {}
-	) {
-		super([field]);
-	}
-
-	public type: "checkbox" | "radio";
-
-	abstract getValueAttribute(
-		ctx: Context,
-		data: Record<string, FormDataValue>,
-		value: T
-	): string;
-
-	abstract isChecked(
-		ctx: Context,
-		data: Record<string, FormDataValue>,
-		value: T
-	): boolean;
-
-	makeInputID(
-		ctx: Context,
-		data: Record<string, FormDataValue>,
-		value: T
-	): string {
-		const value_attr = this.getValueAttribute(ctx, data, value);
-		return (
-			this.options.id ||
-			this.field.name + (value_attr ? "--" + value_attr : "")
-		);
-	}
-
-	getWrapperClasses(
-		ctx: Context,
-		data: Record<string, FormDataValue>,
-		value: T
-	): string[] {
-		return [
-			this.makeInputID(ctx, data, value),
-			this.type,
-			this.field.name.replaceAll(/\W/g, "-"),
-			getRequiredClass(this.field.required),
-			...(this.isChecked(ctx, data, value) ? ["checked"] : []),
-		];
-	}
-
-	async render<Fields extends Record<string, FormField>>(
-		fctx: FormControlContext
-	): Promise<FlatTemplatable> {
-		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-		const { parsed, valid, message } = await this.field.getValue(
-			fctx.ctx,
-			fctx.data
-		);
-		const value = this.getValueAttribute(fctx.ctx, fctx.data, parsed);
-		const id = this.makeInputID(fctx.ctx, fctx.data, parsed);
-		const label =
-			this.options.label != undefined
-				? this.options.label
-				: this.field.name;
-
-		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-		const readonly = this.options.readonly || false;
-		const required = this.field.required;
-
-		return inputWrapper(
-			this.getWrapperClasses(fctx.ctx, fctx.data, parsed),
-
-			/* HTML */ `
-				<input
-					id="${id}"
-					type="${this.type}"
-					name="${fctx.field_name_prefix}${this.options.name ||
-					this.field.name}"
-					${value ? `value="${attribute(value)}"` : ""}
-					${fctx.form_id ? `form="${fctx.form_id}"` : ""}
-					${this.isChecked(fctx.ctx, fctx.data, parsed)
-						? "checked"
-						: ""}
-					${readonly ? "readonly" : ""}
-					${required ? "required" : ""}
-					autocomplete="off"
-					onchange="this.closest('.form-container').querySelectorAll('.form-input__wrapper--${this
-						.field
-						.name}').forEach(e=>e.setAttribute('data-checked','false'));
-				this.closest('.form-input__wrapper').setAttribute('data-checked',this.checked);"
-				/>
-
-				<label for="${id}">${label}</label>
-				<script>
-					(function () {
-						let wrapper = document.currentScript.closest(
-							".form-input__wrapper"
-						);
-						wrapper.setAttribute(
-							"data-checked",
-							wrapper.querySelector("input").checked.toString()
-						);
-					})();
-				</script>
-
-				${~valid && !this.options.hide_errors && fctx.validate
-					? `<div class="input__error">${message}</div>`
-					: ""}
-			`
-		);
-	}
-}

package/src/forms/fields/boolean.test.ts

@@ -1,36 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index";
-
-describe("boolean field", () => {
-	const ctx = {} as any;
-
-	it("validation logic", async () => {
-		const required = new Fields.Boolean(true);
-		const not_required = new Fields.Boolean(false);
-
-		assert.strictEqual((await required.isValueValid(ctx, true)).valid, true);
-		assert.strictEqual((await required.isValueValid(ctx, false)).valid, false);
-		assert.strictEqual((await not_required.isValueValid(ctx, true)).valid, true);
-		assert.strictEqual((await not_required.isValueValid(ctx, false)).valid, true);
-	});
-
-	it("parse function", async () => {
-		const field = new Fields.Boolean(true);
-		const true_response = await field.parse(ctx, true as any);
-		const null_response = await field.parse(ctx, null as any);
-		const true_as_string_response = await field.parse(ctx, "true");
-		const undefined_response = await field.parse(ctx, undefined);
-		const number_response = await field.parse(ctx, 42);
-
-		assert.strictEqual(true_response.parsable, true);
-		assert.strictEqual(true_response.parsed_value, true);
-		assert.strictEqual(null_response.parsable, true);
-		assert.strictEqual(null_response.parsed_value, false);
-		assert.strictEqual(true_as_string_response.parsable, true);
-		assert.strictEqual(true_as_string_response.parsed_value, true);
-		assert.strictEqual(undefined_response.parsable, true);
-		assert.strictEqual(undefined_response.parsed_value, false);
-		assert.strictEqual(number_response.parsable, false);
-		assert.strictEqual(number_response.error, "Please enter a boolean");
-	});
-});

package/src/forms/fields/boolean.ts

@@ -1,63 +0,0 @@
-import { is, predicates } from "@sealcode/ts-predicates";
-import { Context } from "koa";
-import { FormDataValue } from "../form";
-import { FieldParseResult, FormField } from "./field";
-
-const truthy = ["true", "on", "yes", "1"];
-const falsy = ["false", "off", "no", "0"];
-
-export class Boolean<Required extends boolean> extends FormField<
-	Required,
-	boolean
-> {
-	predicate = predicates.boolean;
-	constructor(required: Required, public error_message: string = "") {
-		super(required);
-	}
-
-	public async isValueValid(
-		_: Context,
-		value: boolean
-	): Promise<{ valid: boolean; message: string }> {
-		if (this.required && !value) {
-			return { valid: false, message: this.error_message };
-		}
-		return { valid: true, message: "" };
-	}
-
-	async parse(
-		_: Context,
-		value: FormDataValue
-	): Promise<FieldParseResult<boolean>> {
-		if (is(value, predicates.boolean)) {
-			return { parsable: true, parsed_value: value, error: null };
-		} else if (
-			is(value, predicates.string) &&
-			[...truthy, ...falsy].includes(value)
-		) {
-			return {
-				parsable: true,
-				parsed_value: truthy.includes(value),
-				error: null,
-			};
-		} else if (is(value, predicates.undefined)) {
-			return {
-				parsable: true,
-				parsed_value: false,
-				error: null,
-			};
-		} else if (value === null) {
-			return { parsable: true, parsed_value: false, error: null };
-		} else {
-			return {
-				parsable: false,
-				parsed_value: null,
-				error: "Please enter a boolean",
-			};
-		}
-	}
-
-	public getEmptyValue(): boolean {
-		return false;
-	}
-}

package/src/forms/fields/checkboxed-list.ts

@@ -1,66 +0,0 @@
-import { is, predicates } from "@sealcode/ts-predicates";
-import { Context } from "koa";
-import { FormDataValue } from "../form";
-import {
-	FieldParseResult,
-	FormField,
-	FormFieldValidationResponse,
-} from "./field";
-
-export class ChekboxedListField<Required extends boolean> extends FormField<
-	Required,
-	Record<string, "on">
-> {
-	constructor(
-		public required: Required,
-		public generateOptions: (
-			ctx: Context
-		) => Promise<Record<string, string> | { [i: string]: string }>,
-		public isVisible: (ctx: Context) => Promise<boolean> = () =>
-			Promise.resolve(true)
-	) {
-		super(required);
-	}
-
-	predicate = predicates.array(predicates.string); // TODO: this is probably wrong
-
-	public async isValueValid(
-		_: Context,
-		value: unknown
-	): Promise<FormFieldValidationResponse> {
-		if (is(value, predicates.string)) {
-			return { valid: false, message: "you need an array" };
-		}
-		if (is(value, predicates.null)) {
-			return { valid: false, message: "you need an array" };
-		}
-		return { valid: true, message: "" };
-	}
-
-	async parse(
-		_: Context,
-		raw_value: FormDataValue
-	): Promise<FieldParseResult<Record<string, "on">>> {
-		if (is(raw_value, predicates.object)) {
-			return {
-				parsable: true,
-				parsed_value: Object.fromEntries(
-					Object.entries(raw_value).filter(
-						([, value]) => value === "on"
-					)
-				) as Record<string, "on">,
-				error: null,
-			};
-		} else {
-			return {
-				parsed_value: null,
-				parsable: false,
-				error: "Expected an object",
-			};
-		}
-	}
-
-	public getEmptyValue(): Record<string, "on"> {
-		return {};
-	}
-}

package/src/forms/fields/collection-field.ts

@@ -1,62 +0,0 @@
-import { predicates } from "@sealcode/ts-predicates";
-import { Context } from "koa";
-import { Depromisify, Field, FieldOutput } from "sealious";
-import { FormDataValue } from "../form";
-
-import {
-	FieldParseResult,
-	FormField,
-	FormFieldValidationResponse,
-} from "./field";
-
-export class CollectionField<
-	F extends Field,
-	Required extends boolean
-> extends FormField<Required, FieldOutput<F> | null> {
-	constructor(required: Required, public sealiousField: F) {
-		super(required);
-	}
-
-	predicate = predicates.unknown;
-
-	async parse(
-		ctx: Context,
-		raw_value: FormDataValue
-	): Promise<FieldParseResult<FieldOutput<F> | null>> {
-		if (raw_value === undefined) {
-			return { parsable: true, parsed_value: null, error: null };
-		}
-		const encoded_value = (await this.sealiousField.encode(
-			ctx.$context,
-			raw_value
-		)) as Depromisify<ReturnType<F["encode"]>>;
-		const parsed_value = (await this.sealiousField.decode(
-			ctx.$context,
-			encoded_value,
-			null,
-			{}
-		)) as Depromisify<ReturnType<F["encode"]>>;
-		return {
-			parsable: true,
-			error: null,
-			parsed_value,
-		};
-	}
-
-	public async isValueValid(
-		ctx: Context,
-		value: FieldOutput<F>
-	): Promise<FormFieldValidationResponse> {
-		const { valid, reason } = await this.sealiousField.checkValue(
-			ctx.$context,
-			value,
-			undefined,
-			null
-		);
-		return { valid, message: reason || (!valid ? "Wrong value" : "") };
-	}
-
-	public getEmptyValue(): Depromisify<ReturnType<F["decode"]>> {
-		return "" as unknown as Depromisify<ReturnType<F["decode"]>>;
-	}
-}

package/src/forms/fields/email.test.ts

@@ -1,24 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index";
-
-describe("email field", () => {
-	const ctx = {} as any;
-
-	it("validation logic", async () => {
-		const field = new Fields.EmailField(true);
-
-		assert.strictEqual((await field.isValueValid(ctx, "yes@an.email")).valid, true);
-		assert.strictEqual((await field.isValueValid(ctx, "notanemail")).valid, false);
-	});
-
-	it("parse function", async () => {
-		const field = new Fields.EmailField(true);
-		const string_response = await field.parse(ctx, "42");
-		const number_response = await field.parse(ctx, 42);
-
-		assert.strictEqual(string_response.parsable, true);
-		assert.strictEqual(string_response.parsed_value, "42");
-		assert.strictEqual(number_response.parsable, false);
-		assert.strictEqual(number_response.error, "Please enter a string");
-	});
-});

package/src/forms/fields/email.ts

@@ -1,20 +0,0 @@
-import { predicates } from "@sealcode/ts-predicates";
-import { RegExpField } from "./regexp";
-
-export class EmailField<
-	Required extends boolean
-> extends RegExpField<Required> {
-	predicate = predicates.string;
-	constructor(
-		required: Required,
-		public error_message = "Please enter a proper email address",
-		public default_value = ""
-	) {
-		super(
-			required,
-			/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-			error_message,
-			default_value
-		);
-	}
-}

package/src/forms/fields/enum-multiple.test.ts

@@ -1,31 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index";
-
-describe("enum-multiple field", () => {
-	const ctx = {} as any;
-
-	it("validation logic", async () => {
-		const field = new Fields.EnumMultipleField(true, ["sa", "mp", "le"]);
-
-		assert.strictEqual((await field.isValueValid(ctx, ["sa", "le"])).valid, true);
-		assert.strictEqual((await field.isValueValid(ctx, ["notvalid"])).valid, false);
-		assert.strictEqual((await field.isValueValid(ctx, [42] as any)).valid, false);
-	});
-
-	it("parse function", async () => {
-		const field = new Fields.EnumMultipleField(true, []);
-		const string_array_response = await field.parse(ctx, ["42"]);
-		const number_response = await field.parse(ctx, 42);
-		const string_response = await field.parse(ctx, "sample");
-		const null_response = await field.parse(ctx, null as any);
-
-		assert.strictEqual(string_array_response.parsable, true);
-		assert.deepEqual(string_array_response.parsed_value, ["42"]);
-		assert.strictEqual(number_response.parsable, false);
-		assert.strictEqual(number_response.error, "Please enter a list of strings");
-		assert.strictEqual(string_response.parsable, true);
-		assert.deepEqual(string_response.parsed_value, ["sample"]);
-		assert.strictEqual(null_response.parsable, true);
-		assert.deepEqual(null_response.parsed_value, []);
-	});
-});