@sealcode/sealgen 0.12.0 → 0.12.3

package/lib/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/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/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/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/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/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/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/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/forms/fields/field.js

@@ -1,81 +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;
-    }
-}
-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=field.js.map

package/lib/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/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/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/forms/fields/number.test.js

@@ -1,30 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index.js";
-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

package/lib/forms/fields/pick-from-list.js

@@ -1,31 +0,0 @@
-import { is, predicates } from "@sealcode/ts-predicates";
-import { SimpleFormField } from "./simple-form-field.js";
-export class PickFromListField extends SimpleFormField {
-    constructor(required, generateOptions, customValidation = (ctx, value, instance) => instance.valueInList(ctx, value)) {
-        super(required);
-        this.required = required;
-        this.generateOptions = generateOptions;
-        this.customValidation = customValidation;
-        this.predicate = predicates.string;
-    }
-    isValueValid(ctx, value) {
-        return this.customValidation(ctx, value, this);
-    }
-    async valueInList(ctx, value) {
-        const options = await this.generateOptions(ctx);
-        if (!is(value, predicates.string)) {
-            return { valid: false, message: "not a string" };
-        }
-        if (this.required && !options.map((o) => o.value).includes(value)) {
-            return {
-                valid: false,
-                message: `"${value}" is not one of the options`,
-            };
-        }
-        return { valid: true, message: "" };
-    }
-    getEmptyValue() {
-        return "";
-    }
-}
-//# sourceMappingURL=pick-from-list.js.map

package/lib/forms/fields/pick-from-list.test.js

@@ -1,17 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index.js";
-describe("pick-from-list field", () => {
-    const ctx = {};
-    it("validation logic", async () => {
-        const field = new Fields.PickFromListField(true, async () => {
-            return [
-                { value: "samplev", label: "samplel" },
-                { value: "samplevv", label: "samplell" },
-            ];
-        });
-        assert.strictEqual((await field.isValueValid(ctx, 42)).valid, false);
-        assert.strictEqual((await field.isValueValid(ctx, "samplevv")).valid, true);
-        assert.strictEqual((await field.isValueValid(ctx, "notvalid")).valid, false);
-    });
-});
-//# sourceMappingURL=pick-from-list.test.js.map

package/lib/forms/fields/proxy-field.js

@@ -1,20 +0,0 @@
-import { FormField } from "./field.js";
-export class ProxyFormField extends FormField {
-    constructor(required, name, empty_value, parsed_value) {
-        super(required);
-        this.name = name;
-        this.empty_value = empty_value;
-        this.parsed_value = parsed_value;
-    }
-    getEmptyValue() {
-        return this.empty_value;
-    }
-    async parse() {
-        return {
-            parsable: true,
-            error: null,
-            parsed_value: this.parsed_value,
-        };
-    }
-}
-//# sourceMappingURL=proxy-field.js.map

package/lib/forms/fields/regexp.js

@@ -1,40 +0,0 @@
-import { is, predicates } from "@sealcode/ts-predicates";
-import { FormField } from "./field.js";
-export class RegExpField extends FormField {
-    constructor(required, regexp, error_message, default_value = "") {
-        super(required);
-        this.regexp = regexp;
-        this.error_message = error_message;
-        this.default_value = default_value;
-        this.predicate = predicates.string;
-    }
-    async isValueValid(_, value) {
-        if (!is(value, predicates.string)) {
-            return { valid: false, message: "expected a string" };
-        }
-        if (this.regexp.exec(value)) {
-            return { valid: true, message: "" };
-        }
-        return { valid: false, message: this.error_message };
-    }
-    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 this.default_value || "";
-    }
-}
-//# sourceMappingURL=regexp.js.map

package/lib/forms/fields/regexp.test.js

@@ -1,21 +0,0 @@
-import assert from "assert";
-import { Fields } from "../../index.js";
-describe("regexp field", () => {
-    const ctx = {};
-    it("validation logic", async () => {
-        const field = new Fields.RegExpField(true, /^4/, "error");
-        assert.strictEqual((await field.isValueValid(ctx, "42")).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.RegExpField(true, /^4/, "error");
-        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=regexp.test.js.map

package/lib/forms/fields/reverse-single-reference.js

@@ -1,14 +0,0 @@
-import { FormField } from "./field.js";
-export class ReverseSingleReference extends FormField {
-    constructor(required, sealious_field) {
-        super(required);
-        this.sealious_field = sealious_field;
-    }
-    async parse(ctx, raw_value) {
-        return { parsable: true, error: null, parsed_value: raw_value };
-    }
-    getEmptyValue() {
-        return [];
-    }
-}
-//# sourceMappingURL=reverse-single-reference.js.map

package/lib/forms/fields/simple-form-field.js

@@ -1,20 +0,0 @@
-import { FormField } from "./field.js";
-import { predicates } from "@sealcode/ts-predicates";
-console.log({ FormField });
-export class SimpleFormField extends FormField {
-    async parse(_, raw_value) {
-        return {
-            parsed_value: (raw_value || "").toString(),
-            parsable: true,
-            error: null,
-        };
-    }
-    getEmptyValue() {
-        return "";
-    }
-    constructor(required) {
-        super(required);
-        this.predicate = predicates.string;
-    }
-}
-//# sourceMappingURL=simple-form-field.js.map

package/lib/forms/fields/structured-array.js

@@ -1,18 +0,0 @@
-import { FormField } from "./field.js";
-export class StructuredArrayField extends FormField {
-    constructor(sealious_field) {
-        super(true);
-        this.sealious_field = sealious_field;
-    }
-    async parse(context, value) {
-        return {
-            parsable: true,
-            error: null,
-            parsed_value: value || [],
-        };
-    }
-    getEmptyValue() {
-        return [];
-    }
-}
-//# sourceMappingURL=structured-array.js.map