@sealcode/sealgen 0.11.7 → 0.12.0

package/lib/src/forms/controls/tickable.js

@@ -0,0 +1,75 @@
+import { attribute } from "../../sanitize.js";
+import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper.js";
+import { FormFieldControl } from "./form-field-control.js";
+export class Tickable extends FormFieldControl {
+    constructor(field, options = {}) {
+        super([field]);
+        this.field = field;
+        this.options = options;
+    }
+    makeInputID(ctx, data, value) {
+        const value_attr = this.getValueAttribute(ctx, data, value);
+        return (this.options.id ||
+            this.field.name + (value_attr ? "--" + value_attr : ""));
+    }
+    getWrapperClasses(ctx, data, value) {
+        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(fctx) {
+        // 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>`
+            : ""}
+			`);
+    }
+}
+//# sourceMappingURL=tickable.js.map

package/lib/src/forms/fields/boolean.js

@@ -0,0 +1,51 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+const truthy = ["true", "on", "yes", "1"];
+const falsy = ["false", "off", "no", "0"];
+export class Boolean extends FormField {
+    constructor(required, error_message = "") {
+        super(required);
+        this.error_message = error_message;
+        this.predicate = predicates.boolean;
+    }
+    async isValueValid(_, value) {
+        if (this.required && !value) {
+            return { valid: false, message: this.error_message };
+        }
+        return { valid: true, message: "" };
+    }
+    async parse(_, value) {
+        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",
+            };
+        }
+    }
+    getEmptyValue() {
+        return false;
+    }
+}
+//# sourceMappingURL=boolean.js.map

package/lib/src/forms/fields/boolean.test.js

@@ -0,0 +1,33 @@
+import { describe, it } from "vitest";
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("boolean field", () => {
+    const ctx = {};
+    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);
+        const null_response = await field.parse(ctx, null);
+        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");
+    });
+});
+//# sourceMappingURL=boolean.test.js.map

package/lib/src/forms/fields/checkboxed-list.js

@@ -0,0 +1,40 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField, } from "./field.js";
+export class ChekboxedListField extends FormField {
+    constructor(required, generateOptions, isVisible = () => Promise.resolve(true)) {
+        super(required);
+        this.required = required;
+        this.generateOptions = generateOptions;
+        this.isVisible = isVisible;
+        this.predicate = predicates.array(predicates.string); // TODO: this is probably wrong
+    }
+    async isValueValid(_, value) {
+        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(_, raw_value) {
+        if (is(raw_value, predicates.object)) {
+            return {
+                parsable: true,
+                parsed_value: Object.fromEntries(Object.entries(raw_value).filter(([, value]) => value === "on")),
+                error: null,
+            };
+        }
+        else {
+            return {
+                parsed_value: null,
+                parsable: false,
+                error: "Expected an object",
+            };
+        }
+    }
+    getEmptyValue() {
+        return {};
+    }
+}
+//# sourceMappingURL=checkboxed-list.js.map

package/lib/src/forms/fields/collection-field.js

@@ -0,0 +1,29 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { FormField, } from "./field.js";
+export class CollectionField extends FormField {
+    constructor(required, sealiousField) {
+        super(required);
+        this.sealiousField = sealiousField;
+        this.predicate = predicates.unknown;
+    }
+    async parse(ctx, raw_value) {
+        if (raw_value === undefined) {
+            return { parsable: true, parsed_value: null, error: null };
+        }
+        const encoded_value = (await this.sealiousField.encode(ctx.$context, raw_value));
+        const parsed_value = (await this.sealiousField.decode(ctx.$context, encoded_value, null, {}));
+        return {
+            parsable: true,
+            error: null,
+            parsed_value,
+        };
+    }
+    async isValueValid(ctx, value) {
+        const { valid, reason } = await this.sealiousField.checkValue(ctx.$context, value, undefined, null);
+        return { valid, message: reason || (!valid ? "Wrong value" : "") };
+    }
+    getEmptyValue() {
+        return "";
+    }
+}
+//# sourceMappingURL=collection-field.js.map

package/lib/src/forms/fields/email.js

@@ -0,0 +1,11 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { RegExpField } from "./regexp.js";
+export class EmailField extends RegExpField {
+    constructor(required, error_message = "Please enter a proper email address", 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);
+        this.error_message = error_message;
+        this.default_value = default_value;
+        this.predicate = predicates.string;
+    }
+}
+//# sourceMappingURL=email.js.map

package/lib/src/forms/fields/email.test.js

@@ -0,0 +1,20 @@
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("email field", () => {
+    const ctx = {};
+    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");
+    });
+});
+//# sourceMappingURL=email.test.js.map

package/lib/src/forms/fields/enum-multiple.js

@@ -0,0 +1,47 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+export class EnumMultipleField extends FormField {
+    constructor(required, options, error_message = (options) => options.join(", ")) {
+        super(required);
+        this.options = options;
+        this.error_message = error_message;
+        this.predicate = predicates.enum(this.options);
+    }
+    async isValueValid(_, values) {
+        for (const value of values) {
+            if (!is(value, predicates.string)) {
+                return { valid: false, message: "expected a string" };
+            }
+            if (!this.options.includes(value)) {
+                return { valid: false, message: "invalid value" };
+            }
+        }
+        return { valid: true, message: "" };
+    }
+    async parse(_, value) {
+        if (is(value, predicates.string)) {
+            return { parsable: true, parsed_value: [value], error: null };
+        }
+        else if (is(value, predicates.array(predicates.string))) {
+            return {
+                parsable: true,
+                parsed_value: value,
+                error: null,
+            };
+        }
+        else if (value == null) {
+            return { parsable: true, parsed_value: [], error: null };
+        }
+        else {
+            return {
+                parsable: false,
+                parsed_value: null,
+                error: "Please enter a list of strings",
+            };
+        }
+    }
+    getEmptyValue() {
+        return [];
+    }
+}
+//# sourceMappingURL=enum-multiple.js.map

package/lib/src/forms/fields/enum-multiple.test.js

@@ -0,0 +1,27 @@
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("enum-multiple field", () => {
+    const ctx = {};
+    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])).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);
+        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, []);
+    });
+});
+//# sourceMappingURL=enum-multiple.test.js.map

package/lib/src/forms/fields/enum.js

@@ -0,0 +1,39 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+export class EnumField extends FormField {
+    constructor(required, options, error_message = (options) => options.join(", ")) {
+        super(required);
+        this.options = options;
+        this.error_message = error_message;
+        this.predicate = predicates.enum(this.options);
+    }
+    async isValueValid(_, value) {
+        if (!is(value, predicates.string)) {
+            return { valid: false, message: "expected a string" };
+        }
+        if (this.options.includes(value)) {
+            return { valid: true, message: "" };
+        }
+        return { valid: false, message: this.error_message(this.options) };
+    }
+    async parse(_, value) {
+        if (is(value, predicates.string)) {
+            return {
+                parsable: true,
+                parsed_value: value,
+                error: null,
+            };
+        }
+        else {
+            return {
+                parsable: false,
+                parsed_value: null,
+                error: "Please enter a string",
+            };
+        }
+    }
+    getEmptyValue() {
+        return "";
+    }
+}
+//# sourceMappingURL=enum.js.map

package/lib/src/forms/fields/enum.test.js

@@ -0,0 +1,21 @@
+import assert from "assert";
+import { Fields } from "../../index.js";
+describe("enum field", () => {
+    const ctx = {};
+    it("validation logic", async () => {
+        const field = new Fields.EnumField(true, ["sa", "mp", "le"]);
+        assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
+        assert.strictEqual((await field.isValueValid(ctx, "mp")).valid, true);
+        assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
+    });
+    it("parse function", async () => {
+        const field = new Fields.EnumField(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");
+    });
+});
+//# sourceMappingURL=enum.test.js.map

package/lib/src/forms/fields/existing-sealious-value.js

@@ -0,0 +1,16 @@
+import { PickFromListField } from "./pick-from-list.js";
+export class ExistingSealiousValue extends PickFromListField {
+    constructor(required, field) {
+        super(required, async (ctx) => {
+            const { items } = await field.collection.list(ctx.$context).fetch();
+            return Object.fromEntries(items.map((item) => {
+                const value = item.get(field.name);
+                return [value, value];
+            }));
+        });
+    }
+    getEmptyValue() {
+        return "";
+    }
+}
+//# sourceMappingURL=existing-sealious-value.js.map

package/lib/src/forms/fields/field.js

@@ -0,0 +1,66 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { t } from "../../utils/translate.js";
+export function fieldsToShape(obj) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, value.predicate]));
+}
+export class FormField {
+    constructor(required) {
+        this.required = required;
+        this.predicate = predicates.unknown;
+        this.mapToFilter = (value) => value;
+    }
+    async init(fieldname) {
+        this.name = fieldname;
+    }
+    async _validate(ctx, value) {
+        if (this.required &&
+            (value === "" || value === null || value === undefined)) {
+            return {
+                valid: false,
+                message: t(ctx, "field_is_required", [], "This field is required"),
+            };
+        }
+        return this.isValueValid(ctx, value);
+    }
+    async isValueValid(ctx, value) {
+        return { valid: true, message: "" };
+    }
+    async getValue(ctx, all_form_values) {
+        if (Object.keys(all_form_values || {}).length === 0) {
+            // don't validate on virgin form
+            return {
+                parsed: this.getEmptyValue(),
+                valid: true,
+                message: "",
+                raw: "",
+            };
+        }
+        const raw = all_form_values[this.name];
+        const { parsable, parsed_value, error: parse_error, } = await this.parse(ctx, raw);
+        if (!parsable) {
+            return {
+                valid: false,
+                parsed: this.getEmptyValue(),
+                raw,
+                message: parse_error || "Error",
+            };
+        }
+        const { valid, message } = await this._validate(ctx, parsed_value);
+        return {
+            parsed: parsed_value,
+            valid,
+            message,
+            raw: all_form_values[this.name],
+        };
+    }
+    setMapToFilter(fn) {
+        this.mapToFilter = fn;
+        return this;
+    }
+    //return undefined here to delete a value
+    async getDatabaseValue(ctx, data) {
+        const { parsed } = await this.getValue(ctx, data);
+        return parsed;
+    }
+}
+//# sourceMappingURL=field.js.map

package/lib/src/forms/fields/fields.js

@@ -0,0 +1,16 @@
+export * from "./simple-form-field.js";
+export * from "./checkboxed-list.js";
+export * from "./collection-field.js";
+export * from "./number.js";
+export * from "./pick-from-list.js";
+export * from "./regexp.js";
+export * from "./email.js";
+export * from "./enum.js";
+export * from "./boolean.js";
+export * from "./enum-multiple.js";
+export * from "./existing-sealious-value.js";
+export * from "./file.js";
+export * from "./multiple-files.js";
+export * from "./reverse-single-reference.js";
+export * from "./structured-array.js";
+//# sourceMappingURL=fields.js.map

package/lib/src/forms/fields/file.js

@@ -0,0 +1,53 @@
+import { hasFieldOfType, hasShape, is, predicates, } from "@sealcode/ts-predicates";
+import { File as SealiousFile } from "sealious";
+import { FormField } from "./field.js";
+export class File extends FormField {
+    async parse(ctx, raw_value) {
+        let result;
+        if (raw_value instanceof SealiousFile ||
+            (is(raw_value, predicates.object) &&
+                hasShape({
+                    filename: predicates.string,
+                    id: predicates.string,
+                }, raw_value) &&
+                raw_value.id)) {
+            const file = await SealiousFile.fromID(ctx.$app, raw_value.id);
+            result = {
+                parsed_value: { old: file, new: null },
+                error: null,
+                parsable: true,
+            };
+        }
+        else if (!is(raw_value, predicates.object)) {
+            result = {
+                parsed_value: null,
+                error: "Expected a field with old.id:string, old.filename:string and new?:File",
+                parsable: false,
+            };
+        }
+        else {
+            const old_file = hasFieldOfType(raw_value, "old", predicates.object) &&
+                hasShape({ id: predicates.string, filename: predicates.string }, raw_value.old) &&
+                raw_value.old.id
+                ? await SealiousFile.fromID(ctx.$app, raw_value.old.id)
+                : null;
+            const new_file = hasFieldOfType(raw_value, "new", predicates.array(predicates.object)) && raw_value.new[0] instanceof SealiousFile
+                ? raw_value.new[0]
+                : null;
+            result = {
+                parsable: true,
+                error: null,
+                parsed_value: { old: old_file, new: new_file },
+            };
+        }
+        return result;
+    }
+    async getDatabaseValue(ctx, data) {
+        const { parsed } = await this.getValue(ctx, data);
+        return parsed.new || undefined;
+    }
+    getEmptyValue() {
+        return { old: null, new: null };
+    }
+}
+//# sourceMappingURL=file.js.map

package/lib/src/forms/fields/multiple-files.js

@@ -0,0 +1,15 @@
+import { FormField } from "./field.js";
+export class MultipleFiles extends FormField {
+    constructor(collection_field, getItemId) {
+        super(false);
+        this.collection_field = collection_field;
+        this.getItemId = getItemId;
+    }
+    getEmptyValue() {
+        return undefined;
+    }
+    async parse() {
+        return { parsed_value: undefined, parsable: true, error: null }; // the control is supposed to do the heavy lifting here
+    }
+}
+//# sourceMappingURL=multiple-files.js.map

package/lib/src/forms/fields/number.js

@@ -0,0 +1,45 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+export class NumberField extends FormField {
+    constructor(required, default_value, options = {}) {
+        super(required);
+        this.default_value = default_value;
+        this.options = options;
+        this.predicate = predicates.number;
+    }
+    async isValueValid(_, value) {
+        if ((is(value, predicates.string) &&
+            !isNaN(parseFloat(value)) &&
+            parseFloat(value).toString() == value.trim()) ||
+            is(value, predicates.number) ||
+            ((is(value, predicates.undefined) || value == "") && !this.required)) {
+            return { valid: true, message: "" };
+        }
+        return { valid: false, message: "Proszę wprowadzić liczbę" };
+    }
+    async parse(_, value) {
+        if ((is(value, predicates.string) &&
+            !isNaN(parseFloat(value)) &&
+            parseFloat(value).toString() == value.trim()) ||
+            is(value, predicates.number)) {
+            return {
+                parsable: true,
+                parsed_value: this.options.decimalDigits
+                    ? parseFloat(parseFloat(value.toString()).toFixed(this.options.decimalDigits))
+                    : parseFloat(value.toString()),
+                error: null,
+            };
+        }
+        else {
+            return {
+                parsable: false,
+                parsed_value: null,
+                error: "Please enter a number",
+            };
+        }
+    }
+    getEmptyValue() {
+        return this.default_value;
+    }
+}
+//# sourceMappingURL=number.js.map

package/lib/src/forms/fields/number.test.js

@@ -0,0 +1,31 @@
+import assert from "assert";
+import * as Sealgen from "../../index.js";
+const { Fields } = Sealgen;
+describe("number field", () => {
+    const ctx = {};
+    it("validation logic", async () => {
+        const required = new Fields.NumberField(true, 0);
+        const not_required = new Fields.NumberField(false, 0);
+        assert.strictEqual((await required.isValueValid(ctx, 42)).valid, true);
+        assert.strictEqual((await required.isValueValid(ctx, "42")).valid, true);
+        assert.strictEqual((await required.isValueValid(ctx, "notvalid")).valid, false);
+        assert.strictEqual((await not_required.isValueValid(ctx, "")).valid, true);
+    });
+    it("parse function", async () => {
+        const required = new Fields.NumberField(true, 0);
+        const decimal_digits = new Fields.NumberField(true, 0, { decimalDigits: 1 });
+        const number_as_string_response = await required.parse(ctx, "42");
+        const number_response = await required.parse(ctx, 42);
+        const not_a_number_response = await required.parse(ctx, "notanumber");
+        const decimal_number_response = await decimal_digits.parse(ctx, 42.42);
+        assert.strictEqual(number_as_string_response.parsable, true);
+        assert.strictEqual(number_as_string_response.parsed_value, 42);
+        assert.strictEqual(number_response.parsable, true);
+        assert.strictEqual(number_response.parsed_value, 42);
+        assert.strictEqual(not_a_number_response.parsable, false);
+        assert.strictEqual(not_a_number_response.error, "Please enter a number");
+        assert.strictEqual(decimal_number_response.parsable, true);
+        assert.strictEqual(decimal_number_response.parsed_value, 42.4);
+    });
+});
+//# sourceMappingURL=number.test.js.map