@sealcode/sealgen 0.12.0 → 0.12.2

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

@@ -1,75 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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