@sealcode/sealgen 0.11.8 → 0.12.0

package/dist/forms/fields/checkboxed-list.js

@@ -0,0 +1,49 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import {
+  FormField
+} from "./field.js";
+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 {};
+  }
+}
+export {
+  ChekboxedListField
+};
+//# sourceMappingURL=checkboxed-list.js.map

package/dist/forms/fields/collection-field.js

@@ -0,0 +1,47 @@
+import { predicates } from "@sealcode/ts-predicates";
+import {
+  FormField
+} from "./field.js";
+class CollectionField extends FormField {
+  constructor(required, sealiousField) {
+    super(required);
+    this.sealiousField = sealiousField;
+    this.predicate = predicates.unknown;
+  }
+  async parse(ctx, raw_value) {
+    if (raw_value === void 0) {
+      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,
+      void 0,
+      null
+    );
+    return { valid, message: reason || (!valid ? "Wrong value" : "") };
+  }
+  getEmptyValue() {
+    return "";
+  }
+}
+export {
+  CollectionField
+};
+//# sourceMappingURL=collection-field.js.map

package/dist/forms/fields/email.js

@@ -0,0 +1,19 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { RegExpField } from "./regexp.js";
+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;
+  }
+}
+export {
+  EmailField
+};
+//# sourceMappingURL=email.js.map

package/dist/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/dist/forms/fields/enum-multiple.js

@@ -0,0 +1,47 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class EnumMultipleField extends FormField {
+  constructor(required, options, error_message = (options2) => options2.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 [];
+  }
+}
+export {
+  EnumMultipleField
+};
+//# sourceMappingURL=enum-multiple.js.map

package/dist/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/dist/forms/fields/enum.js

@@ -0,0 +1,41 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+class EnumField extends FormField {
+  constructor(required, options, error_message = (options2) => options2.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 "";
+  }
+}
+export {
+  EnumField
+};
+//# sourceMappingURL=enum.js.map

package/dist/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/dist/forms/fields/existing-sealious-value.js

@@ -0,0 +1,21 @@
+import { PickFromListField } from "./pick-from-list.js";
+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 "";
+  }
+}
+export {
+  ExistingSealiousValue
+};
+//# sourceMappingURL=existing-sealious-value.js.map

package/dist/forms/fields/field.js

@@ -0,0 +1,82 @@
+import { predicates } from "@sealcode/ts-predicates";
+import { t } from "../../utils/translate.js";
+function fieldsToShape(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [key, value.predicate])
+  );
+}
+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 === void 0)) {
+      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) {
+      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 {
+  FormField,
+  fieldsToShape
+};
+//# sourceMappingURL=field.js.map

package/dist/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/dist/forms/fields/file.js

@@ -0,0 +1,63 @@
+import {
+  hasFieldOfType,
+  hasShape,
+  is,
+  predicates
+} from "@sealcode/ts-predicates";
+import Sealious from "sealious";
+import { FormField } from "./field.js";
+class File extends FormField {
+  async parse(ctx, raw_value) {
+    let result;
+    if (raw_value instanceof Sealious.File || is(raw_value, predicates.object) && hasShape(
+      {
+        filename: predicates.string,
+        id: predicates.string
+      },
+      raw_value
+    ) && raw_value.id) {
+      const file = await Sealious.File.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 Sealious.File.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 || void 0;
+  }
+  getEmptyValue() {
+    return { old: null, new: null };
+  }
+}
+export {
+  File
+};
+//# sourceMappingURL=file.js.map

package/dist/forms/fields/multiple-files.js

@@ -0,0 +1,18 @@
+import { FormField } from "./field.js";
+class MultipleFiles extends FormField {
+  constructor(collection_field, getItemId) {
+    super(false);
+    this.collection_field = collection_field;
+    this.getItemId = getItemId;
+  }
+  getEmptyValue() {
+    return void 0;
+  }
+  async parse() {
+    return { parsed_value: void 0, parsable: true, error: null };
+  }
+}
+export {
+  MultipleFiles
+};
+//# sourceMappingURL=multiple-files.js.map

package/dist/forms/fields/number.js

@@ -0,0 +1,42 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+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\u0119 wprowadzi\u0107 liczb\u0119" };
+  }
+  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;
+  }
+}
+export {
+  NumberField
+};
+//# sourceMappingURL=number.js.map

package/dist/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

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

@@ -0,0 +1,34 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { SimpleFormField } from "./simple-form-field.js";
+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 "";
+  }
+}
+export {
+  PickFromListField
+};
+//# sourceMappingURL=pick-from-list.js.map

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

@@ -0,0 +1,17 @@
+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/dist/forms/fields/proxy-field.js

@@ -0,0 +1,23 @@
+import { FormField } from "./field.js";
+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
+    };
+  }
+}
+export {
+  ProxyFormField
+};
+//# sourceMappingURL=proxy-field.js.map

package/dist/forms/fields/regexp.js

@@ -0,0 +1,42 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+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 || "";
+  }
+}
+export {
+  RegExpField
+};
+//# sourceMappingURL=regexp.js.map