@sealcode/sealgen 0.11.8 → 0.12.2

package/dist/forms/controls/radio.js

@@ -0,0 +1,28 @@
+import { Tickable } from "./tickable.js";
+class Radio extends Tickable {
+  constructor(field, value, options) {
+    super(field, options);
+    this.field = field;
+    this.value = value;
+    this.type = "radio";
+  }
+  makeInputID() {
+    return this.field.name + "-" + this.value.replaceAll(/\W/g, "-");
+  }
+  getValueAttribute() {
+    return this.value;
+  }
+  getWrapperClasses(ctx, data, value) {
+    return [
+      ...super.getWrapperClasses(ctx, data, value),
+      this.value.replaceAll(/\W/g, "-")
+    ];
+  }
+  isChecked(_ctx, _data, value) {
+    return this.value === value;
+  }
+}
+export {
+  Radio
+};
+//# sourceMappingURL=radio.js.map

package/dist/forms/controls/reverse-single-reference.js

@@ -0,0 +1 @@
+//# sourceMappingURL=reverse-single-reference.js.map

package/dist/forms/controls/simple-input.js

@@ -0,0 +1,85 @@
+import { tempstream } from "tempstream";
+import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper.js";
+import { renderAttributes } from "../../utils/render-attributes.js";
+import { FormFieldControl } from "./form-field-control.js";
+class SimpleInput extends FormFieldControl {
+  constructor(field, options) {
+    super([field]);
+    this.field = field;
+    this.options = options || {};
+  }
+  async preInput(_ctx, _data) {
+    return "";
+  }
+  getType() {
+    return this.options.type || "text";
+  }
+  getLabel() {
+    return this.options.label != void 0 ? this.options.label : this.field.name;
+  }
+  getID() {
+    return this.options.id || this.field.name;
+  }
+  getPlaceholder() {
+    return this.options.placeholder === "" ? "" : this.options.placeholder || this.getType();
+  }
+  async getInputAttributes(fctx) {
+    const readonly = this.options.readonly || false;
+    const required = this.field.required;
+    const { parsed, raw, valid } = await this.field.getValue(
+      fctx.ctx,
+      fctx.data
+    );
+    return Object.fromEntries([
+      ["id", this.getID()],
+      ["type", this.getType()],
+      ["name", `${fctx.field_name_prefix}${this.field.name}`],
+      [
+        "value",
+        !valid && raw ? raw.toString() : parsed !== void 0 && parsed !== null ? parsed?.toString() || "" : ""
+      ],
+      ...fctx.form_id ? [["form", fctx.form_id]] : [],
+      ["placeholder", this.getPlaceholder()],
+      ...readonly ? [["readonly", true]] : [],
+      ...required ? [["required", true]] : [],
+      ...!this.options.autocomplete ? [["autocomplete", "off"]] : [],
+      ...this.options.step ? [["step", this.options.step]] : []
+    ]);
+  }
+  async postInput(_) {
+    return this.options.suffix ? (
+      /* HTML */
+      `<span class="suffix">${this.options.suffix}</span>`
+    ) : "";
+  }
+  async renderInput(_ctx, attributes_str, _data) {
+    return `<input ${attributes_str} />`;
+  }
+  async render(fctx) {
+    const id = this.getID();
+    const label = this.getLabel();
+    const type = this.getType();
+    const { valid, message } = await this.field.getValue(
+      fctx.ctx,
+      fctx.data
+    );
+    return inputWrapper(
+      [id, type, getRequiredClass(this.field.required)],
+      tempstream`
+				${label ? `<label for="${id}">${label}</label>` : ""}
+				${await this.preInput(fctx.ctx, fctx.data)}
+				${this.renderInput(
+        fctx.ctx,
+        renderAttributes(await this.getInputAttributes(fctx)),
+        fctx.data
+      )}
+				${this.postInput(fctx.ctx)}
+				${~valid && !this.options.hide_errors && fctx.validate ? `<div class="input__error">${message}</div>` : ""}
+			`
+    );
+  }
+}
+export {
+  SimpleInput
+};
+//# sourceMappingURL=simple-input.js.map

package/dist/forms/controls/textarea.js

@@ -0,0 +1,40 @@
+import { SimpleInput } from "./simple-input.js";
+class Textarea extends SimpleInput {
+  constructor(field, options = {}) {
+    super(field, options);
+    this.field = field;
+    this.options = options;
+  }
+  renderDescription() {
+    return this.options.description ? (
+      /* HTML */
+      `<div class="form-input__description">
+					${this.options.description}
+			  </div>`
+    ) : "";
+  }
+  async getInputAttributes(fctx) {
+    const original = await super.getInputAttributes(fctx);
+    let onkeydown = original.onkeydown || "";
+    if (this.options.autogrow) {
+      onkeydown += `;this.style.height = '5px';this.style.height = Math.max((this.scrollHeight)+32, ${((this.options.rows || 2) + 1) * 16} )+'px';`;
+    }
+    return {
+      ...original,
+      rows: this.options.rows ? this.options.rows.toString() : false,
+      cols: this.options.cols ? this.options.cols.toString() : false,
+      onkeydown
+    };
+  }
+  async renderInput(ctx, attributes, data) {
+    const { parsed: value } = await this.field.getValue(ctx, data);
+    return (
+      /* HTML */
+      `<textarea ${attributes}>${value}</textarea>`
+    );
+  }
+}
+export {
+  Textarea
+};
+//# sourceMappingURL=textarea.js.map

package/dist/forms/controls/tickable.js

@@ -0,0 +1,72 @@
+import { attribute } from "../../sanitize.js";
+import { getRequiredClass, inputWrapper } from "../../utils/input-wrapper.js";
+import { FormFieldControl } from "./form-field-control.js";
+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) {
+    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 != void 0 ? this.options.label : this.field.name;
+    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>` : ""}
+			`
+    );
+  }
+}
+export {
+  Tickable
+};
+//# sourceMappingURL=tickable.js.map

package/dist/forms/fields/boolean.js

@@ -0,0 +1,49 @@
+import { is, predicates } from "@sealcode/ts-predicates";
+import { FormField } from "./field.js";
+const truthy = ["true", "on", "yes", "1"];
+const falsy = ["false", "off", "no", "0"];
+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;
+  }
+}
+export {
+  Boolean
+};
+//# sourceMappingURL=boolean.js.map

package/dist/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, void 0);
+    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/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