@sealcode/sealgen 0.18.8 → 0.19.0

package/lib/forms/controls/table.js

@@ -2,7 +2,7 @@ import { hasShape, is, predicates } from "@sealcode/ts-predicates";
 import qs from "qs";
 import { tempstream } from "tempstream";
 import { FormControl } from "./form-control.js";
-const TO_REPLACE = "____$$$$";
+const TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER = "TABLE_ROW_INDEX________________";
 class Table extends FormControl {
   constructor(table_field, options) {
     super();
@@ -11,25 +11,46 @@ class Table extends FormControl {
     this.role = "input";
   }
   async render(fctx) {
-    let { parsed: rows } = await this.table_field.getValue(
-      fctx.ctx,
-      fctx.data
-    );
+    let rows = fctx.data.raw_values?.[this.table_field.name];
     if (!rows) {
       rows = [];
     }
-    const make_row = (row, row_index) => {
+    const get_row_fctx = (row, row_index) => {
+      return typeof row_index == "number" ? {
+        data: {
+          raw_values: Object.fromEntries(
+            Object.entries(
+              row
+            ).map(([key, value]) => [
+              this.table_field.columns[key].name,
+              value
+            ])
+          ) || {},
+          messages: [],
+          field_messages: {}
+        }
+      } : {};
+    };
+    const make_row = async (row, row_index) => {
       return (
         /* HTML */
         tempstream`<tr>
-				 ${Object.entries(this.table_field.columns).map(([key]) => {
-          return tempstream`<td>${this.options.render_fields[key](
-            fctx,
-            `${this.table_field.name}[${row_index}][${key}]`,
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            row?.[key] || ""
-          )}</td>`;
-        })}
+				 ${(await Promise.all(
+          Object.entries(this.table_field.columns).map(
+            ([column_name]) => {
+              const inner_fctx = get_row_fctx(
+                row,
+                row_index
+              );
+              return tempstream`<td>${this.options.subfield_controls[column_name].render({ ...fctx, ...inner_fctx })}</td>`;
+            }
+          )
+        )).map(
+          (html) => html.replaceAll(
+            TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER,
+            row_index.toString()
+          )
+        )}
 				 ${this.options.allow_removing ? (
           /* HTML */
           `<td>
@@ -79,26 +100,25 @@ class Table extends FormControl {
 						${rows?.map((row, index) => make_row(row, index))}
 					</tbody>
 				</table>
-				<template> ${make_row(null, TO_REPLACE)} </template>
+				<template>
+					${make_row(null, TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER)}
+				</template>
 
 				${/* because of https://github.com/ljharb/qs/issues/252 we have to
     put the indexes in the field names */
     this.options.allow_adding ? (
       /* HTML */
       `<button
-									onclick="const template = this.closest('turbo-frame').querySelector('template');
- const tbody = this.closest('turbo-frame').querySelector('tbody');
-const orig_template = template.innerHTML;
-template.innerHTML = orig_template.replaceAll('${TO_REPLACE}', tbody.querySelectorAll('tr').length);
- tbody.appendChild(template.cloneNode(true).content);
-template.innerHTML = orig_template;"
+									data-controller="table-add-button"
+									data-action="click->table-add-button#addRow"
+									data-table-placeholder="${TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER}"
 								>
-									add
+									${this.options.label_add || "add"}
 								</button>
 								<noscript>
 									<input
 										type="submit"
-										value="${this.options.label_add || "add"}"
+										value="add"
 										form="${fctx.form_id}"
 										formnovalidate
 										formaction="${this.getActionURL(
@@ -177,7 +197,8 @@ template.innerHTML = orig_template;"
           ctx,
           {
             raw_values: await form.extractRawValues(ctx),
-            messages: []
+            messages: [],
+            field_messages: {}
           },
           false
         )
@@ -185,8 +206,29 @@ template.innerHTML = orig_template;"
       await next();
     });
   }
+  setAllowRemoving(value) {
+    this.options.allow_removing = value;
+    return this;
+  }
+  setAllowAdding(value) {
+    this.options.allow_adding = value;
+    return this;
+  }
+  setLabel(value) {
+    this.options.label = value;
+    return this;
+  }
+  setRemoveLabel(value) {
+    this.options.label_remove = value;
+    return this;
+  }
+  setAddLabel(value) {
+    this.options.label_add = value;
+    return this;
+  }
 }
 export {
+  TABLE_COLUMN_FIELD_INDEX_PLACEHOLDER,
   Table
 };
 //# sourceMappingURL=table.js.map

package/lib/forms/controls/textarea.js

@@ -27,10 +27,12 @@ class Textarea extends SimpleInput {
     };
   }
   async renderInput(ctx, attributes, data) {
-    const { parsed: value } = await this.field.getValue(ctx, data);
+    const { parsed: value } = await this.field.getParsedValue(ctx, data);
     return (
       /* HTML */
-      `<textarea ${attributes}>${value || ""}</textarea>`
+      `<textarea ${attributes}>
+${String(value) || ""}</textarea
+		>`
     );
   }
 }

package/lib/forms/controls/tickable.js

@@ -25,16 +25,24 @@ class Tickable extends FormFieldControl {
       parsed: _parsed,
       valid,
       message
-    } = await this.field.getValue(fctx.ctx, fctx.data, true);
+    } = await this.field.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values,
+      true
+    );
     const parsed = _parsed === null ? this.options.default_value : _parsed;
-    const value = this.getValueAttribute(fctx.ctx, fctx.data, parsed);
-    const id = this.makeInputID(fctx.ctx, fctx.data, parsed);
+    const value = this.getValueAttribute(
+      fctx.ctx,
+      fctx.data.raw_values,
+      parsed
+    );
+    const id = this.makeInputID(fctx.ctx, fctx.data.raw_values, 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.type,
-      this.getWrapperClasses(fctx.ctx, fctx.data, parsed),
+      this.getWrapperClasses(fctx.ctx, fctx.data.raw_values, parsed),
       /* HTML */
       `
 				<input
@@ -43,7 +51,7 @@ class Tickable extends FormFieldControl {
 					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" : ""}
+					${this.isChecked(fctx.ctx, fctx.data.raw_values, parsed) ? "checked" : ""}
 					${readonly ? "readonly" : ""}
 					${required ? "required" : ""}
 					autocomplete="off"

package/lib/forms/fields/boolean.js

@@ -1,4 +1,5 @@
 import { is, predicates } from "@sealcode/ts-predicates";
+import { Checkbox } from "../controls/checkbox.js";
 import { FormField } from "./field.js";
 const truthy = ["true", "on", "yes", "1"];
 const falsy = ["false", "off", "no", "0"];
@@ -42,6 +43,19 @@ class Boolean extends FormField {
   getEmptyValue() {
     return false;
   }
+  getControl() {
+    return new Checkbox(this, { label: this.name });
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return !!parsed;
+  }
+  async sealiousValueToForm(_, value) {
+    return value ? "true" : "false";
+  }
 }
 export {
   Boolean

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

@@ -1,4 +1,5 @@
 import { is, predicates } from "@sealcode/ts-predicates";
+import { CheckboxedListInput } from "../controls/checkboxed-list-input.js";
 import {
   FormField
 } from "./field.js";
@@ -42,6 +43,9 @@ class CheckboxedListField extends FormField {
   getEmptyValue() {
     return {};
   }
+  getControl() {
+    return new CheckboxedListInput(this, { label: this.name });
+  }
 }
 export {
   CheckboxedListField

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

@@ -1,4 +1,5 @@
 import { predicates } from "@sealcode/ts-predicates";
+import { SimpleInput } from "../controls/controls.js";
 import {
   FormField
 } from "./field.js";
@@ -40,6 +41,14 @@ class CollectionField extends FormField {
   getEmptyValue() {
     return "";
   }
+  getControl() {
+    return new SimpleInput(this);
+  }
+  generateFieldDeclaration(field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${String(
+      field_info.is_required
+    )}, ${vars.sealious_field})`;
+  }
 }
 export {
   CollectionField

package/lib/forms/fields/color.js

@@ -0,0 +1,10 @@
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class Color extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "color");
+  }
+}
+export {
+  Color
+};
+//# sourceMappingURL=color.js.map

package/lib/forms/fields/coordinates.js

@@ -0,0 +1,49 @@
+import { SimpleInput } from "../controls/simple-input.js";
+import { SimpleFormField } from "./simple-form-field.js";
+class Coordinates extends SimpleFormField {
+  async parse(_, raw_value) {
+    if (typeof raw_value == "string") {
+      return {
+        parsed_value: raw_value?.split(",").map((e) => parseFloat(e)),
+        parsable: true,
+        error: null
+      };
+    }
+    if (Array.isArray(raw_value)) {
+      return {
+        parsed_value: raw_value.map((e) => parseFloat(e)),
+        parsable: true,
+        error: null
+      };
+    }
+    return {
+      parsed_value: null,
+      parsable: false,
+      error: "should be an array or string"
+    };
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed || void 0;
+  }
+  async postSealiousCreate() {
+  }
+  async postSealiousEdit() {
+  }
+  getControl() {
+    return new SimpleInput(this, {
+      label: this.name,
+      type: this.type
+    });
+  }
+  getEmptyValue() {
+    return [0, 0];
+  }
+}
+export {
+  Coordinates
+};
+//# sourceMappingURL=coordinates.js.map

package/lib/forms/fields/date.js

@@ -0,0 +1,34 @@
+import { SimpleInput } from "../controls/simple-input.js";
+import { SimpleFormField } from "./simple-form-field.js";
+class DateField extends SimpleFormField {
+  constructor(required) {
+    super(required, "date");
+  }
+  getEmptyValue() {
+    return /* @__PURE__ */ new Date("1970-01-01 00:00");
+  }
+  async parse(ctx, raw_value) {
+    return {
+      error: null,
+      parsable: true,
+      parsed_value: new Date(raw_value)
+    };
+  }
+  getControl() {
+    return new SimpleInput(this, { label: this.name, type: this.type });
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    if (!parsed) {
+      return null;
+    }
+    return `${parsed.getFullYear()}-${(parsed.getMonth() + 1).toString().padStart(2, "0")}-${parsed.getDate().toString().padStart(2, "0")}`;
+  }
+}
+export {
+  DateField
+};
+//# sourceMappingURL=date.js.map

package/lib/forms/fields/datetime.js

@@ -0,0 +1,46 @@
+import { SimpleInput } from "../controls/controls.js";
+import { SimpleFormField } from "./simple-form-field.js";
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+class DateTime extends SimpleFormField {
+  constructor(required) {
+    super(required, "datetime-local");
+  }
+  getEmptyValue() {
+    return null;
+  }
+  async parse(ctx, raw_value) {
+    const parsed_value = new Date(raw_value);
+    return { parsable: true, error: null, parsed_value };
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    if (parsed == null) {
+      return null;
+    }
+    return new Date(parsed).getTime();
+  }
+  getControl() {
+    return new SimpleInput(this, {
+      label: this.name,
+      type: this.type
+    });
+  }
+  async sealiousValueToForm(ctx, value) {
+    if (value == null) {
+      return "";
+    }
+    const d = new Date(value);
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(
+      d.getDate()
+    )}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+  }
+}
+export {
+  DateTime
+};
+//# sourceMappingURL=datetime.js.map

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

@@ -0,0 +1,81 @@
+import { CheckboxedListField } from "./checkboxed-list.js";
+import { wrapKeyName } from "../../utils/wrap-attributes.js";
+class DeepReverseSingleReferenceList extends CheckboxedListField {
+  constructor(sealious_field) {
+    super(false, async (ctx) => {
+      const { items } = await ctx.$app.collections[sealious_field.target_collection].list(ctx.$context).fetch();
+      return items.map((s) => ({
+        label: this.item_label_getter(s),
+        value: s.id
+      }));
+    });
+    this.sealious_field = sealious_field;
+    this.item_label_getter = (item) => item.get("name");
+  }
+  setItemLabelGetter(getter) {
+    this.item_label_getter = getter;
+  }
+  getSealiousCreateValue() {
+    throw new Error(
+      "This field is not set directly through field value, but instead relies on postSealiousCreate and postSealiousEdit"
+    );
+  }
+  async postSealiousCreate(ctx, created_item, form_data) {
+    const { items: existing_links } = await ctx.$app.collections[this.sealious_field.intermediary_collection].list(ctx.$context).filter({
+      [this.sealious_field.referencing_field]: created_item.id
+    }).fetch();
+    const { parsed: value } = await this.getParsedValue(
+      ctx,
+      form_data.raw_values,
+      false
+    );
+    const should_exist_ids = Object.entries(value || {}).filter(([, value2]) => value2 === "on").map(([key]) => key);
+    const to_delete = existing_links.filter(
+      (link) => !should_exist_ids.includes(
+        link.get(
+          this.sealious_field.intermediary_field_that_points_there
+        )
+      )
+    );
+    const to_create_ids = should_exist_ids.filter(
+      (id) => !existing_links.map(
+        (link) => (
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          link.get(
+            this.sealious_field.intermediary_field_that_points_there
+          )
+        )
+      ).includes(id)
+    );
+    await Promise.all(
+      to_delete.map((item) => {
+        return item.remove(ctx.$context);
+      })
+    );
+    const promises = to_create_ids.map(async (id) => {
+      await this.sealious_field.getReferencingCollection().create(ctx.$context, {
+        [this.sealious_field.referencing_field]: created_item.id,
+        [this.sealious_field.intermediary_field_that_points_there]: id
+      });
+    });
+    await Promise.all(promises);
+  }
+  async postSealiousEdit(ctx, edited_item, value) {
+    return this.postSealiousCreate(ctx, edited_item, value);
+  }
+  async sealiousValueToForm(_ctx, value) {
+    return Object.fromEntries((value || []).map((id) => [id, "on"]));
+  }
+  generateFieldDeclaration(_field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+  }
+  generateCreateValueGetter(field_info, vars) {
+    return `${wrapKeyName(
+      field_info.name
+    )}: undefined /* handled below in postSealiousCreate */`;
+  }
+}
+export {
+  DeepReverseSingleReferenceList
+};
+//# sourceMappingURL=deep-reverse-single-reference-list.js.map

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

@@ -0,0 +1,122 @@
+import {
+  FieldTypes as SealiousFieldTypes
+} from "sealious";
+import { Boolean, TextBasedSimpleField } from "./fields.js";
+import { sealiousToFormField } from "./get-field-for-sealious.js";
+import { Table } from "./table.js";
+import { Table as TableControl } from "../controls/table.js";
+import { HiddenInput } from "../controls/hidden-input.js";
+function getReferencingFields(sealious_field) {
+  const referencing_collection = sealious_field.collection.app.collections[sealious_field.referencing_collection];
+  if (!referencing_collection) {
+    throw new Error(
+      "Unknown collection: " + sealious_field.referencing_collection
+    );
+  }
+  return referencing_collection.fields;
+}
+class DeepReverseSingleReferenceTable extends Table {
+  constructor(sealious_field) {
+    super({
+      selected: new Boolean(false),
+      [sealious_field.referencing_field]: new TextBasedSimpleField(true),
+      [sealious_field.intermediary_field_that_points_there]: new TextBasedSimpleField(true),
+      ...Object.fromEntries(
+        Object.values(getReferencingFields(sealious_field)).filter(
+          (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+        ).map((field) => [field.name, sealiousToFormField(field)])
+      )
+    });
+    this.sealious_field = sealious_field;
+  }
+  getControl() {
+    return new TableControl(this, {
+      label: this.name,
+      allow_adding: false,
+      subfield_controls: {
+        selected: this.columns.selected.getControl(),
+        [this.sealious_field.referencing_field]: new HiddenInput(
+          this.columns[this.sealious_field.referencing_field]
+        ),
+        [this.sealious_field.intermediary_field_that_points_there]: new HiddenInput(
+          this.columns[this.sealious_field.intermediary_field_that_points_there]
+        ),
+        ...Object.fromEntries(
+          Object.values(getReferencingFields(this.sealious_field)).filter(
+            (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+          ).map((field) => [
+            field.name,
+            this.columns[field.name].getControl()
+          ])
+        )
+      }
+    });
+  }
+  getSealiousCreateValue(_fctx) {
+    throw new Error("Method not implemented.");
+  }
+  async postSealiousCreate(ctx, created_item, form_data) {
+    const { items: to_delete } = await ctx.$app.collections["${toKebabCase(referencing_collection)}"].list(ctx.$context).filter({ "${referencing_field}": created_item.id }).fetch();
+    await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
+    const referencing_fields = getReferencingFields(this.sealious_field);
+    const { parsed: value } = await this.getParsedValue(
+      ctx,
+      form_data.raw_values,
+      false
+    );
+    const promises = (value || []).filter((s) => s.selected == true).map(async (link_info) => {
+      await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(ctx.$context, {
+        "${referencing_field}": created_item.id,
+        "${intermediary_field_that_points_there}": String(
+          link_info["${intermediary_field_that_points_there}"]
+        ),
+        ...Object.fromEntries(
+          Object.values(referencing_fields).filter(
+            (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+          ).map((field) => [field.name, link_info[field.name]])
+        )
+      });
+    });
+    await Promise.all(promises);
+  }
+  postSealiousEdit(ctx, edited_item, form_data) {
+    return this.postSealiousCreate(ctx, edited_item, form_data);
+  }
+  async sealiousValueToForm(ctx, _value, item) {
+    const referencing_fields = getReferencingFields(this.sealious_field);
+    return Object.fromEntries(
+      await Promise.all([
+        this.sealious_field.collection.list(ctx.$context).fetch(),
+        this.sealious_field.getReferencingCollection().list(ctx.$context).fetch()
+      ]).then(
+        ([{ items: targets }, { items: links }]) => targets.map((target) => {
+          return {
+            selected: (item.get(
+              this.sealious_field.name
+            ) || []).includes(target.id) ? "on" : "off",
+            [this.sealious_field.referencing_field]: item.id,
+            [this.sealious_field.intermediary_field_that_points_there]: target.id,
+            ...Object.fromEntries(
+              Object.values(referencing_fields).filter(
+                (field) => !(field instanceof SealiousFieldTypes.SingleReference)
+              ).map((field) => [
+                field.name,
+                links.find(
+                  (e) => e.get(
+                    this.sealious_field.intermediary_field_that_points_there
+                  ) == target.id && e.get(
+                    this.sealious_field.referencing_field
+                  ) == item.id
+                )?.get("rank") || 0
+              ])
+            )
+          };
+        }).entries()
+      )
+    );
+  }
+}
+export {
+  DeepReverseSingleReferenceTable
+};
+//# sourceMappingURL=deep-reverse-single-reference-table.js.map

package/lib/forms/fields/email.js

@@ -1,5 +1,6 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { RegExpField } from "./regexp.js";
+import { SimpleInput } from "../controls/controls.js";
 class EmailField extends RegExpField {
   constructor(required, error_message = "Please enter a proper email address", default_value = "") {
     super(
@@ -12,6 +13,12 @@ class EmailField extends RegExpField {
     this.default_value = default_value;
     this.predicate = predicates.string;
   }
+  setErrorMessage(message) {
+    this.error_message = message;
+  }
+  getControl() {
+    return new SimpleInput(this, { label: this.name, type: "email" });
+  }
 }
 export {
   EmailField

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

@@ -0,0 +1,32 @@
+import { CheckboxedListField } from "./checkboxed-list.js";
+class EnumMultipleSealious extends CheckboxedListField {
+  constructor(sealious_field) {
+    super(
+      sealious_field.required,
+      async (ctx) => (await sealious_field.getAllowedValues(ctx.$context)).map(
+        (value) => ({ value, label: value })
+      )
+    );
+    this.sealious_field = sealious_field;
+  }
+  generateFieldDeclaration(field_info, vars) {
+    return `new ${vars.form_field_types}.${this.constructor.name}(${vars.sealious_field})`;
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    const result = Object.entries(parsed || {}).filter(([, value]) => value == "on").map(([key]) => key);
+    return result;
+  }
+  async sealiousValueToForm(ctx, sealious_value) {
+    return Object.fromEntries(
+      (sealious_value || []).map((key) => [key, "on"])
+    );
+  }
+}
+export {
+  EnumMultipleSealious
+};
+//# sourceMappingURL=enum-multiple-sealious.js.map