@sealcode/sealgen 0.18.10 → 0.19.0

package/lib/forms/fields/get-field-for-sealious.js

@@ -0,0 +1,213 @@
+import {
+  FieldTypes as SealiousFieldTypes
+} from "sealious";
+import { Boolean as BooleanField } from "./boolean.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+import { File } from "./file.js";
+import { StructuredArray as StructuredArrayField } from "./structured-array.js";
+import { Color } from "./color.js";
+import { DateField } from "./date.js";
+import { DateTime } from "./datetime.js";
+import { EmailField } from "./email.js";
+import { Float } from "./float.js";
+import { HTML } from "./html.js";
+import { Int } from "./int.js";
+import { JSONField } from "./json.js";
+import { Password } from "./password.js";
+import { Text } from "./text.js";
+import { Markdown } from "./markdown.js";
+import { DeepReverseSingleReferenceTable } from "./deep-reverse-single-reference-table.js";
+import { DeepReverseSingleReferenceList } from "./deep-reverse-single-reference-list.js";
+import { Coordinates } from "./coordinates.js";
+import { PickFromListSealious } from "./pick-from-list-sealious.js";
+import { SingleReference } from "./single-reference.js";
+import extract_fields_from_collection from "../../utils/extract-fields-from-collection.js";
+import { EnumMultipleSealious } from "./enum-multiple-sealious.js";
+import { URLField } from "./url.js";
+import { Image } from "./image.js";
+function sealiousToFormField(sealious_field) {
+  if (sealious_field instanceof SealiousFieldTypes.Boolean) {
+    return new BooleanField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Color) {
+    return new Color(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.ControlAccess) {
+    const target_field = sealious_field.virtual_field;
+    return sealiousToFormField(target_field);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Date) {
+    return new DateField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DateTime) {
+    return new DateTime(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DeepReverseSingleReference) {
+    const referencing_collection = sealious_field.collection.app.collections[sealious_field.referencing_collection];
+    if (!referencing_collection) {
+      throw new Error(
+        "Unknown collection: " + sealious_field.referencing_collection
+      );
+    }
+    if (Object.keys(referencing_collection.fields).length == 2) {
+      return new DeepReverseSingleReferenceList(
+        sealious_field
+      );
+    } else {
+      return new DeepReverseSingleReferenceTable(
+        sealious_field
+      );
+    }
+  }
+  if (sealious_field instanceof SealiousFieldTypes.DisallowUpdate) {
+    return sealiousToFormField(
+      sealious_field.virtual_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Email) {
+    return new EmailField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Enum) {
+    return new PickFromListSealious(
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.EnumMultiple) {
+    return new EnumMultipleSealious(
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.File) {
+    return new File(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Float) {
+    return new Float(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.HTML) {
+    return new HTML(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Image) {
+    return new Image(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Int) {
+    return new Int(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.JsonObject) {
+    return new JSONField(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Password) {
+    return new Password(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.SettableBy) {
+    return sealiousToFormField(
+      sealious_field.virtual_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.SingleReference) {
+    return new SingleReference(
+      false,
+      sealious_field
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Text) {
+    return new Text(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Username) {
+    return new Text(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Url) {
+    return new URLField(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Money) {
+    return new Float(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Markdown) {
+    return new Markdown(sealious_field.required);
+  }
+  if (sealious_field instanceof SealiousFieldTypes.Coordinates) {
+    return new Coordinates(
+      sealious_field.required
+    );
+  }
+  if (sealious_field instanceof SealiousFieldTypes.StructuredArray) {
+    return new StructuredArrayField(
+      sealious_field
+    );
+  }
+  return new TextBasedSimpleField(false);
+}
+async function sealiousFieldInfoToFormField(field_info) {
+  switch (field_info.type) {
+    case "boolean":
+      return new BooleanField(field_info.is_required);
+    case "color":
+      return new Color(field_info.is_required);
+    case "date":
+      return new DateField(field_info.is_required);
+    case "datetime":
+      return new DateTime(field_info.is_required);
+    case "deep-reverse-single-reference": {
+      const referencing_fields = await extract_fields_from_collection(
+        field_info.referencing_collection
+      );
+      if (referencing_fields.length == 2) {
+        return new DeepReverseSingleReferenceList({});
+      } else {
+        return new DeepReverseSingleReferenceTable({});
+      }
+    }
+    case "email":
+      return new EmailField(field_info.is_required);
+    case "enum":
+      return new PickFromListSealious({});
+    case "enum-multiple":
+      return new EnumMultipleSealious({});
+    case "file":
+      return new File(field_info.is_required);
+    case "float":
+      return new Float(field_info.is_required);
+    case "html":
+      return new HTML(field_info.is_required);
+    case "image":
+      return new Image(field_info.is_required);
+    case "int":
+      return new Int(field_info.is_required);
+    case "json-object":
+      return new JSONField(field_info.is_required);
+    case "password":
+      return new Password(field_info.is_required);
+    case "single-reference":
+      return new SingleReference(false, {});
+    case "text":
+      return new Text(field_info.is_required);
+    case "username":
+      return new Text(field_info.is_required);
+    case "url":
+      return new URLField(field_info.is_required);
+    case "money":
+      return new Float(field_info.is_required);
+    case "markdown":
+      return new Markdown(field_info.is_required);
+    case "coordinates":
+      return new Coordinates(field_info.is_required);
+    case "structured-array":
+      return new StructuredArrayField(
+        new SealiousFieldTypes.StructuredArray({})
+      );
+    default:
+      return new TextBasedSimpleField(false);
+  }
+}
+export {
+  sealiousFieldInfoToFormField,
+  sealiousToFormField
+};
+//# sourceMappingURL=get-field-for-sealious.js.map

package/lib/forms/fields/html.js

@@ -0,0 +1,14 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class HTML extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+}
+export {
+  HTML
+};
+//# sourceMappingURL=html.js.map

package/lib/forms/fields/image.js

@@ -0,0 +1,13 @@
+import { Image as ImageControl } from "../controls/image.js";
+import { File as FileField } from "./file.js";
+class Image extends FileField {
+  getControl() {
+    return new ImageControl(
+      this
+    );
+  }
+}
+export {
+  Image
+};
+//# sourceMappingURL=image.js.map

package/lib/forms/fields/int.js

@@ -0,0 +1,23 @@
+import { NumberBasedSimpleField } from "./simple-form-field.js";
+class Int extends NumberBasedSimpleField {
+  constructor(required) {
+    super(required, "number");
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    if (parsed == null) {
+      return void 0;
+    }
+    if (isNaN(parsed)) {
+      return void 0;
+    } else
+      return parsed;
+  }
+}
+export {
+  Int
+};
+//# sourceMappingURL=int.js.map

package/lib/forms/fields/json.js

@@ -0,0 +1,31 @@
+import { Textarea } from "../controls/textarea.js";
+import { SimpleFormField } from "./simple-form-field.js";
+class JSONField extends SimpleFormField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+  getEmptyValue() {
+    return {};
+  }
+  async parse(ctx, raw_value) {
+    return {
+      parsable: true,
+      error: null,
+      parsed_value: JSON.parse(raw_value)
+    };
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed;
+  }
+}
+export {
+  JSONField
+};
+//# sourceMappingURL=json.js.map

package/lib/forms/fields/markdown.js

@@ -0,0 +1,14 @@
+import { Textarea } from "../controls/textarea.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class Markdown extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "text");
+  }
+  getControl() {
+    return new Textarea(this);
+  }
+}
+export {
+  Markdown
+};
+//# sourceMappingURL=markdown.js.map

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

@@ -1,4 +1,5 @@
 import { FormField } from "./field.js";
+import { MultipleFiles as MultipleFilesControl } from "../controls/multiple-files.js";
 class MultipleFiles extends FormField {
   constructor(collection_field, getItemId) {
     super(false);
@@ -11,6 +12,9 @@ class MultipleFiles extends FormField {
   async parse() {
     return { parsed_value: void 0, parsable: true, error: null };
   }
+  getControl() {
+    return new MultipleFilesControl(this);
+  }
 }
 export {
   MultipleFiles

package/lib/forms/fields/number.js

@@ -1,4 +1,5 @@
 import { is, predicates } from "@sealcode/ts-predicates";
+import { SimpleInput } from "../controls/simple-input.js";
 import { FormField } from "./field.js";
 class NumberField extends FormField {
   constructor(required, default_value, options = {}) {
@@ -35,6 +36,11 @@ class NumberField extends FormField {
   getEmptyValue() {
     return this.default_value;
   }
+  getControl() {
+    return new SimpleInput(this, {
+      type: "number"
+    });
+  }
 }
 export {
   NumberField

package/lib/forms/fields/password.js

@@ -0,0 +1,13 @@
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class Password extends TextBasedSimpleField {
+  constructor(required) {
+    super(required, "password");
+  }
+  async sealiousValueToForm(ctx, value) {
+    return void 0;
+  }
+}
+export {
+  Password
+};
+//# sourceMappingURL=password.js.map

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

@@ -0,0 +1,17 @@
+import { PickFromListField } from "./pick-from-list.js";
+class PickFromListSealious extends PickFromListField {
+  constructor(sealious_field) {
+    super(
+      sealious_field.required,
+      async (ctx) => sealious_field.getAllowedValues(ctx.$app).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})`;
+  }
+}
+export {
+  PickFromListSealious
+};
+//# sourceMappingURL=pick-from-list-sealious.js.map

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

@@ -1,6 +1,7 @@
 import { is, predicates } from "@sealcode/ts-predicates";
-import { SimpleFormField } from "./simple-form-field.js";
-class PickFromListField extends SimpleFormField {
+import { Dropdown } from "../controls/dropdown.js";
+import { TextBasedSimpleField } from "./simple-form-field.js";
+class PickFromListField extends TextBasedSimpleField {
   constructor(required, generateOptions, customValidation = (ctx, value, instance) => instance.valueInList(ctx, value)) {
     super(required);
     this.required = required;
@@ -27,6 +28,9 @@ class PickFromListField extends SimpleFormField {
   getEmptyValue() {
     return "";
   }
+  getControl() {
+    return new Dropdown(this);
+  }
 }
 export {
   PickFromListField

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

@@ -16,6 +16,9 @@ class ProxyFormField extends FormField {
       parsed_value: this.parsed_value
     };
   }
+  getControl() {
+    throw new Error("This field does not have a default control assigned");
+  }
 }
 export {
   ProxyFormField

package/lib/forms/fields/regexp.js

@@ -1,4 +1,5 @@
 import { is, predicates } from "@sealcode/ts-predicates";
+import { SimpleInput } from "../controls/simple-input.js";
 import { FormField } from "./field.js";
 class RegExpField extends FormField {
   constructor(required, regexp, error_message, default_value = "") {
@@ -35,6 +36,19 @@ class RegExpField extends FormField {
   getEmptyValue() {
     return this.default_value || "";
   }
+  getControl() {
+    return new SimpleInput(this, { label: this.name });
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed || "";
+  }
+  async sealiousValueToForm(ctx, sealious_value) {
+    return sealious_value || "";
+  }
 }
 export {
   RegExpField

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

@@ -1,10 +1,20 @@
 import { predicates } from "@sealcode/ts-predicates";
 import { FormField } from "./field.js";
+import { SimpleInput } from "../controls/simple-input.js";
 class SimpleFormField extends FormField {
-  constructor(required) {
+  constructor(required, type = "text") {
     super(required);
+    this.type = type;
     this.predicate = predicates.string;
   }
+  async sealiousValueToForm(ctx, value) {
+    if (value === null) {
+      return "";
+    }
+    return String(value);
+  }
+}
+class TextBasedSimpleField extends SimpleFormField {
   async parse(_, raw_value) {
     return {
       parsed_value: (raw_value || "").toString(),
@@ -12,11 +22,59 @@ class SimpleFormField extends FormField {
       error: null
     };
   }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed || "";
+  }
+  async postSealiousCreate(ctx, created_item) {
+  }
+  async postSealiousEdit(ctx, edited_item) {
+  }
+  getControl() {
+    return new SimpleInput(this, {
+      label: this.name,
+      type: this.type
+    });
+  }
   getEmptyValue() {
     return "";
   }
 }
+class NumberBasedSimpleField extends SimpleFormField {
+  async parse(_, raw_value) {
+    return {
+      parsed_value: parseFloat(raw_value) || 0,
+      parsable: true,
+      error: null
+    };
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed || 0;
+  }
+  async postSealiousCreate() {
+  }
+  async postSealiousEdit() {
+  }
+  getControl() {
+    return new SimpleInput(this, {
+      label: this.name,
+      type: this.type
+    });
+  }
+  getEmptyValue() {
+    return 0;
+  }
+}
 export {
-  SimpleFormField
+  NumberBasedSimpleField,
+  SimpleFormField,
+  TextBasedSimpleField
 };
 //# sourceMappingURL=simple-form-field.js.map

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

@@ -0,0 +1,44 @@
+import { CollectionField } from "./collection-field.js";
+import { SingleReferenceDropdown } from "../controls/single-reference.js";
+import { toPascalCase } from "js-convert-case";
+class SingleReference extends CollectionField {
+  getControl() {
+    return new SingleReferenceDropdown(this, {
+      label: this.name,
+      getLabel: (item) => item.id
+    });
+  }
+  async getSealiousCreateValue(fctx) {
+    const { parsed } = await this.getParsedValue(
+      fctx.ctx,
+      fctx.data.raw_values
+    );
+    return parsed || void 0;
+  }
+  async sealiousValueToForm(ctx, value) {
+    return value || void 0;
+  }
+  generateImportsForFieldList(field_info) {
+    if (!field_info.target) {
+      throw new Error("Expected 'target' attribute in field info");
+    }
+    return [
+      {
+        what: toPascalCase(field_info.target),
+        from: "src/back/collections/collections.js"
+      }
+    ];
+  }
+  generateFieldDeclaration(field_info, vars) {
+    if (!field_info.target) {
+      throw new Error("Expected 'target' attribute in field info");
+    }
+    return `new ${vars.form_field_types}.${this.constructor.name}<typeof ${toPascalCase(field_info.target)}, ${String(
+      field_info.is_required
+    )}, typeof ${vars.sealious_field}>(${String(field_info.is_required)}, ${vars.sealious_field})`;
+  }
+}
+export {
+  SingleReference
+};
+//# sourceMappingURL=single-reference.js.map

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

@@ -1,21 +1,72 @@
-import { FormField } from "./field.js";
-class StructuredArrayField extends FormField {
+import { Table as TableControl } from "../controls/table.js";
+import {
+  sealiousToFormField
+} from "./get-field-for-sealious.js";
+import { Table } from "./table.js";
+class StructuredArray extends Table {
   constructor(sealious_field) {
-    super(true);
+    const columns = Object.fromEntries(
+      Object.entries(sealious_field.subfields).map(
+        ([key, sealious_field2]) => [
+          key,
+          sealiousToFormField(sealious_field2)
+        ]
+      )
+    );
+    super(columns);
     this.sealious_field = sealious_field;
   }
-  async parse(_context, value) {
-    return {
-      parsable: true,
-      error: null,
-      parsed_value: value || []
-    };
+  getControl() {
+    return new TableControl(this, {
+      label: this.name,
+      subfield_controls: Object.fromEntries(
+        Object.entries(this.columns).map(([column_name, subfield]) => [
+          column_name,
+          subfield.getControl()
+        ])
+      ),
+      allow_adding: true,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      make_new_row: () => ({})
+    });
   }
-  getEmptyValue() {
-    return [];
+  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
+    );
+    return parsed || this.getEmptyValue();
+  }
+  async sealiousValueToForm(ctx, sealiousValue) {
+    return Promise.all(
+      (sealiousValue || []).map(
+        async (element) => Object.fromEntries(
+          await Promise.all(
+            Object.entries(element).map(async ([key, value]) => {
+              const form_subfield = this.columns[key];
+              if (!form_subfield) {
+                return [key, ""];
+              }
+              return [
+                key,
+                await form_subfield.sealiousValueToForm(
+                  ctx,
+                  value,
+                  {}
+                )
+              ];
+            })
+          )
+        )
+      )
+    );
   }
 }
 export {
-  StructuredArrayField
+  StructuredArray
 };
 //# sourceMappingURL=structured-array.js.map