@sealcode/sealgen 0.18.10 → 0.19.2

package/lib/add-verbose-crud.js

@@ -1,119 +0,0 @@
-import _locreq from "locreq";
-import { escape_url_params } from "./utils/escape-url-params.js";
-import prompts from "prompts";
-import { toKebabCase, toPascalCase } from "js-convert-case";
-import { listCollections } from "./utils/list-collections.js";
-import { collectionListTemplate } from "./templates/shared/collection-list.js";
-import { writeFile } from "./utils/write-file.js";
-import { curryImportPath, importPath } from "./utils/import-path.js";
-import { sharedCrudFormFields } from "./templates/shared/shared-crud-form-fields.js";
-import { generateRoutes } from "./generate-routes.js";
-import { createItemFormTemplate } from "./templates/shared/collection-create-form.js";
-import { editItemFormTemplate } from "./templates/shared/collection-edit-form.js";
-import { itemDeleteTemplate } from "./templates/shared/item-delete.js";
-async function addVerboseCRUD(params, app_directory = process.cwd()) {
-  const target_locreq = _locreq(app_directory);
-  prompts.override(params);
-  const response = await prompts([
-    {
-      type: "autocomplete",
-      name: "collection",
-      message: "Which sealious collection do you like to add CRUD forms for?",
-      choices: (await listCollections()).map((collection) => ({
-        title: collection,
-        value: collection
-      }))
-    },
-    {
-      type: "text",
-      name: "url",
-      message: "Enter a full absolute path for the new route (for example: /admin/users/:id/edit): ",
-      validate: (s) => s.trim()[0] == "/" ? true : "Should start with a '/'",
-      initial: function(_, { collection }) {
-        return "/" + toKebabCase(collection);
-      }
-    }
-  ]);
-  const collection_name = response.collection;
-  const url = response.url;
-  const list_action_name = toPascalCase(collection_name) + "CRUDList";
-  const create_action_name = toPascalCase(collection_name) + "CRUDCreate";
-  const edit_action_name = toPascalCase(collection_name) + "CRUDEdit";
-  const delete_action_name = toPascalCase(collection_name) + "CRUDDelete";
-  const list_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/index.list.tsx`
-  );
-  const list_content = await collectionListTemplate(
-    collection_name,
-    list_action_name,
-    list_path,
-    {
-      post_import_js: `import { ${create_action_name}URL, ${edit_action_name}URL, ${delete_action_name}URL } from "${importPath(
-        list_path,
-        "src/back/routes/urls.ts"
-      )}";`,
-      post_header_html: `<a href={${create_action_name}URL}> Create </a>`,
-      render_item: (collection_name2) => `	async renderItem(ctx: Context, item: CollectionItem<typeof ${toPascalCase(
-        collection_name2
-      )}>) {
-					   return <tr>
-						   {displayFields.map(({ field, format }) => {
-							   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-							   const value = item.get(field as any);
-							   return <td>{format ? format(value, item) : value}</td>;
-						   })}
-                           <td><div class="sealious-list__actions">
-                               <a href={${edit_action_name}URL(item.id)}>Edit</a>
-                               <a data-turbo-method="POST" data-turbo-confirm="Delete item?" href={${delete_action_name}URL(item.id)}>Delete</a>
-                               </div>
-                           </td>
-					   </tr>;
-				   }`
-    }
-  );
-  await writeFile(list_path, list_content);
-  const fields_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/shared.ts`
-  );
-  const fields_content = await sharedCrudFormFields(
-    collection_name,
-    fields_path
-  );
-  await writeFile(fields_path, fields_content);
-  const create_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/create.form.ts`
-  );
-  const create_content = await createItemFormTemplate(
-    create_action_name,
-    create_path,
-    collection_name,
-    list_action_name
-  );
-  await writeFile(create_path, create_content);
-  const edit_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/[id]/edit.form.ts`
-  );
-  const edit_content = await editItemFormTemplate(
-    edit_action_name,
-    edit_path,
-    collection_name,
-    list_action_name
-  );
-  await writeFile(edit_path, edit_content);
-  const delete_path = target_locreq.resolve(
-    `src/back/routes/${escape_url_params(url)}/[id]/delete.page.tsx`
-  );
-  const base_import_path = curryImportPath(delete_path);
-  const delete_content = await itemDeleteTemplate(
-    delete_action_name,
-    collection_name,
-    list_action_name,
-    base_import_path
-  );
-  await writeFile(delete_path, delete_content);
-  await generateRoutes();
-}
-export {
-  addVerboseCRUD
-};
-//# sourceMappingURL=add-verbose-crud.js.map

package/lib/crud-field-snippets.js

@@ -1,52 +0,0 @@
-import _locreq from "locreq";
-import prompts from "prompts";
-import { getFieldHandler } from "./templates/shared/shared-crud-form-fields.js";
-import extract_fields_from_collection from "./utils/extract-fields-from-collection.js";
-import { listCollections } from "./utils/list-collections.js";
-import { formatWithPrettier } from "./utils/prettier.js";
-async function crudFieldSnippets(params, app_directory = process.cwd()) {
-  const target_locreq = _locreq(app_directory);
-  prompts.override(params);
-  const { collection_name } = await prompts([
-    {
-      type: "autocomplete",
-      name: "collection_name",
-      message: "Which sealious collection do you like to show a CRUD field config for?",
-      choices: (await listCollections()).map((collection) => ({
-        title: collection,
-        value: collection
-      }))
-    }
-  ]);
-  const all_fields = await extract_fields_from_collection(collection_name);
-  const { field_name } = await prompts([
-    {
-      type: "autocomplete",
-      name: "field_name",
-      message: `Which field do you want to show CRUD config for??`,
-      choices: all_fields.map((field) => ({
-        title: field.name,
-        value: field.name
-      }))
-    }
-  ]);
-  const handler = await getFieldHandler(
-    collection_name,
-    all_fields.find((e) => e.name == field_name),
-    (p) => p
-  );
-  console.log(`
-
-### Field in shared.ts
-
-${handler.field}
-
-### Control in shared.ts
-
-${await formatWithPrettier(handler.controls)}
-`);
-}
-export {
-  crudFieldSnippets
-};
-//# sourceMappingURL=crud-field-snippets.js.map

package/lib/find-css-includes.js

@@ -1,3 +0,0 @@
-import _locreq from "locreq";
-const target_locreq = _locreq(process.cwd());
-//# sourceMappingURL=find-css-includes.js.map

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

@@ -1 +0,0 @@
-//# sourceMappingURL=reverse-single-reference.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";
-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/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,41 +0,0 @@
-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/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/reverse-single-reference.js

@@ -1,17 +0,0 @@
-import { FormField } from "./field.js";
-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 [];
-  }
-}
-export {
-  ReverseSingleReference
-};
-//# sourceMappingURL=reverse-single-reference.js.map

package/lib/templates/shared/handlers/boolean.js

@@ -1,14 +0,0 @@
-const boolean_handler = async (_, { name }, ___, { is_required_expr, fields_var }) => ({
-  field: `${name}: new Fields.Boolean(${is_required_expr})`,
-  controls: `new Controls.Checkbox(${fields_var}.${name}, { label: "${name}" })`,
-  initial_value_edit: {
-    fallback_value: `"false"`,
-    parsed_value: `String(item.get("${name}"))`
-  },
-  main_value_sealious: `!!data.${name}`,
-  fallback_value_sealious: "false"
-});
-export {
-  boolean_handler
-};
-//# sourceMappingURL=boolean.js.map

package/lib/templates/shared/handlers/date.js

@@ -1,8 +0,0 @@
-const date_handler = async (_, { name }, ___, { fields_var }) => ({
-  controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}", type: "date"})`,
-  fallback_value_sealious: `undefined`
-});
-export {
-  date_handler
-};
-//# sourceMappingURL=date.js.map

package/lib/templates/shared/handlers/deep-reverse-single-reference.js

@@ -1,209 +0,0 @@
-import { toKebabCase, toPascalCase } from "js-convert-case";
-import extract_fields_from_collection from "../../../utils/extract-fields-from-collection.js";
-const deep_reverse_single_reference_handler = async (collection_name, {
-  name,
-  target,
-  referencing_collection,
-  intermediary_field_that_points_there,
-  referencing_field
-}, ___, { is_required_expr, fields_var }) => {
-  if (!referencing_collection || !target || !intermediary_field_that_points_there || !referencing_field) {
-    console.warn(
-      "missing referencing_collection, target, intermediary_field_that_points_there, or referencing_field member in extracted field info"
-    );
-    return { field: "" };
-  }
-  const referencing_fields = await extract_fields_from_collection(
-    referencing_collection
-  );
-  if (referencing_fields.length == 2) {
-    const post_create = (get_id) => `{
-			 const item_id = ${get_id};
-			 // First, we remove links refering to current item
-			 const {items: existing_links } = (await ctx.$app.collections["${referencing_collection}"]
-				 .list(ctx.$context)
-				 .filter({"${referencing_field}": item_id})
-				 .fetch()
-			 )
-			  const should_exist_ids = Object.entries(
-				  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-				  (data["${name}"] as unknown as Record<string, string>) || {}
-			  )
-				  .filter(([, value]) => value === "on")
-				  .map(([key]) => key);
-			  const to_delete = existing_links.filter(
-				  (link) => !should_exist_ids.includes(link.get("${intermediary_field_that_points_there}"))
-			  );
-			  const to_create_ids = should_exist_ids.filter(
-				  (id) => !existing_links.map((link) => link.get("${intermediary_field_that_points_there}")).includes(id)
-			  );
-			  await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
-			  // Then, we iterate over all selected values and insert appropriate missing links
-			  const promises = to_create_ids.map(async (id) => {
-				  await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
-					  ctx.$context,
-					  {
-						  "${referencing_field}": item_id,
-						  "${intermediary_field_that_points_there}": id,
-					  }
-				  );
-			  });
-			  await Promise.all(promises);
-		 }`;
-    return {
-      field: `${name}: new Fields.CheckboxedListField(${is_required_expr}, async (ctx) => {
-				 const { items } = await ctx.$app.collections["${target}"]
-					 .list(ctx.$context)
-					 .fetch();
-
-				 return items.map((s) => ({
-					 label: s.get("name"),
-					 value: s.id,
-				 }));
-			 })`,
-      controls: `new Controls.CheckboxedListInput(${fields_var}.${name}, {
-				label: "${name}",
-			})`,
-      post_edit: post_create(`await this.getID(ctx)`),
-      post_create: post_create(`created.id`),
-      initial_value_edit: `Object.fromEntries((item.get("${name}") || []).map(id=>[id, "on"]))`,
-      sealious_value: () => ""
-    };
-  } else {
-    const initial_value_function_name = `get${toPascalCase(
-      name
-    )}TableInitialValues`;
-    const post_create = (get_id) => `{
-			const item_id = ${get_id};
-			// First, we remove links refering to current item
-			const { items: to_delete } = await ctx.$app.collections[
-				"${toKebabCase(referencing_collection)}"
-			]
-				.list(ctx.$context)
-				.filter({ "${referencing_field}": item_id })
-				.fetch();
-			await Promise.all(to_delete.map((item) => item.remove(ctx.$context)));
-
-			// Then, we iterate over all selected values and insert appropriate entries for the subcategories relation
-
-			const promises = (data["${name}"] || [])
-				.filter((s) => s.selected == true)
-				.map(async (link_info) => {
-					await ctx.$app.collections["${toKebabCase(referencing_collection)}"].create(
-						ctx.$context,
-						{
-							"${referencing_field}": item_id,
-							"${intermediary_field_that_points_there}": String(link_info["${intermediary_field_that_points_there}"]),
-							${referencing_fields.filter(
-      ({ type }) => type !== "single-reference"
-    ).map(
-      (field) => `"${field.name}": link_info["${field.name}"]`
-    ).join(",\n")}
-						}
-					);
-				});
-
-			await Promise.all(promises);
-		}`;
-    const initial_value = `(await ${initial_value_function_name}(ctx,item)) as unknown as FormDataValue`;
-    return {
-      imports: {
-        shared: `import type { CollectionItem } from "sealious"; import type { Context } from "koa";`,
-        edit: `import {${initial_value_function_name}} from "../shared.js"; import type { FormDataValue } from "@sealcode/sealgen";`
-      },
-      field: `
-			  ${name}: new Fields.Table({
-				  selected: new Fields.Boolean(false),
-				  "${referencing_field}": new Fields.SimpleFormField(true),
-				  "${intermediary_field_that_points_there}": new Fields.SimpleFormField(true),
-				  ${referencing_fields.filter(({ type }) => type !== "single-reference").map(
-        (field) => `${field.name}: new Fields.SimpleFormField(true)`
-      ).join(",\n")}
-			  })`,
-      controls: `
-                new Controls.Table(${fields_var}.${name}, {
-                      render_fields: {
-						  selected: (fctx, name, value) => /* HTML */ \`<input
-							  type="checkbox"
-							  name=\${name}
-							  \${value?.toString() == "true" ? "checked" : ""}
-							  form="\${fctx.form_id}"
-							  autocomplete="off"
-						  />\`,
-						  "${referencing_field}": (fctx, name, value) => /* HTML */ \`<input
-							  type="hidden"
-							  name=\${name}
-							  value="\${value}"
-							  form="\${fctx.form_id}"
-						  />\`,
-						  "${intermediary_field_that_points_there}": (fctx, name, value) => /* HTML */ \`<input
-							  type="hidden"
-							  name=\${name}
-							  value="\${value}"
-							  form="\${fctx.form_id}"
-						  />\`,
-						 ${referencing_fields.filter(
-        ({ type }) => type !== "single-reference"
-      ).map(
-        (field) => `${field.name}: (fctx, name, value) => /* HTML */ \`<input
-										  name=\${name}
-										  value="\${value}"
-										  form="\${fctx.form_id}"
-										  autocomplete="off"
-									  />\``
-      ).join(",\n")}
-                      },
-                      allow_adding: false,
-				  })`,
-      top_level_shared: `export async function ${initial_value_function_name}(
-					ctx: Context,
-                    item: CollectionItem<typeof ${toPascalCase(
-        collection_name
-      )}>
-				) {
-                    // convert from an array to array-like object
-					return Object.fromEntries(
-						await Promise.all([
-							ctx.$app.collections["${toKebabCase(target)}"].list(ctx.$context).fetch(),
-							ctx.$app.collections["${toKebabCase(
-        referencing_collection
-      )}"].list(ctx.$context).fetch(),
-						]).then(([{ items: targets }, { items: links }]) =>
-							targets
-								.map((target) => {
-									return {
-										selected: (item.get("${name}") || []).includes(
-											target.id
-										)
-											? "on"
-											: "off",
-										"${referencing_field}": item.id,
-										"${intermediary_field_that_points_there}": target.id,
-                                        ${referencing_fields.filter(
-        ({ type }) => type !== "single-reference"
-      ).map(
-        (field) => `"${field.name}": links
-												.find(
-													(e) =>
-														e.get("${intermediary_field_that_points_there}") == target.id &&
-														e.get("${referencing_field}") == item.id
-												)
-												?.get("rank") || 0,`
-      ).join(",\n")}
-									};
-								})
-								.entries()
-						)
-					);
-				}`,
-      initial_value_edit: initial_value,
-      initial_value_create: initial_value,
-      post_edit: post_create(`await this.getID(ctx)`),
-      post_create: post_create(`created.id`)
-    };
-  }
-};
-export {
-  deep_reverse_single_reference_handler
-};
-//# sourceMappingURL=deep-reverse-single-reference.js.map

package/lib/templates/shared/handlers/default.js

@@ -1,49 +0,0 @@
-import { toPascalCase } from "js-convert-case";
-const default_handler = async (collection_name, { name, is_readonly, is_required }, _, __, ___, fields_var = `${toPascalCase(collection_name)}FormFields`) => {
-  const required_s = `${toPascalCase(
-    collection_name
-  )}.fields.${name}.required`;
-  const fallback_value_initial = `""`;
-  const fallback_value_sealious = `""`;
-  const main_value_initial = `item.get("${name}")`;
-  const main_value_sealious = `data["${name}"]`;
-  const parsed_value = main_value_initial;
-  return {
-    is_required,
-    name,
-    post_create: "",
-    imports: { shared: "", edit: "" },
-    hide_field: is_readonly,
-    field: `${name}: new Fields.CollectionField(${required_s}, ${toPascalCase(
-      collection_name
-    )}.fields.${name})`,
-    hide_control: is_readonly,
-    controls: `new Controls.SimpleInput(${fields_var}.${name}, { label: "${name}"})`,
-    is_required_expr: `${toPascalCase(
-      collection_name
-    )}.fields.${name}.required`,
-    fields_var,
-    top_level_shared: "",
-    hide_initial_value_edit: is_readonly,
-    initial_value_edit: {
-      fallback_value: fallback_value_initial,
-      main_value: main_value_initial,
-      parsed_value
-    },
-    hide_initial_value_create: is_readonly,
-    initial_value_create: "",
-    pre_edit: "",
-    post_edit: "",
-    pre_create: "",
-    main_value_sealious,
-    fallback_value_sealious,
-    sealious_value: (result) => {
-      return result.is_required ? `${result.name}: ${result.main_value_sealious}` : `${result.name}: ${result.main_value_sealious} != null ? ${result.main_value_sealious} : ${result.fallback_value_sealious}`;
-    },
-    hide_sealious_value: is_readonly
-  };
-};
-export {
-  default_handler
-};
-//# sourceMappingURL=default.js.map

package/lib/templates/shared/handlers/enum.js

@@ -1,19 +0,0 @@
-import { toPascalCase } from "js-convert-case";
-const enum_handler = async (collection_name, { name }, _, { fields_var }) => ({
-  // this assertion and import is only necessary because required fields
-  // in Sealious lose the type information. Once this is fixed, we can remove this import here
-  imports: { shared: `import type { FieldTypes } from "sealious";` },
-  field: `${name}: new Fields.PickFromListField(
-			${toPascalCase(collection_name)}.fields["${name}"].required,
-			async (ctx) =>
-				// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-				(${toPascalCase(collection_name)}.fields["${name}"])
-					.getAllowedValues(ctx.$app)
-					.map((value) => ({ value, label: value }))
-		)`,
-  controls: `new Controls.Dropdown(${fields_var}.${name}, { label: "${name}"})`
-});
-export {
-  enum_handler
-};
-//# sourceMappingURL=enum.js.map

package/lib/templates/shared/handlers/file.js

@@ -1,23 +0,0 @@
-import { toCamelCase } from "js-convert-case";
-const file_handler = async (_, { name, is_required }, importPath, { is_required_expr }) => {
-  const tempname = toCamelCase("prepared-" + name);
-  return {
-    imports: {
-      shared: `import { TheFileManager } from "${importPath(
-        "src/back/file-manager.js"
-      )}";`
-    },
-    field: `${name}: new Fields.File(${is_required_expr}, TheFileManager)`,
-    initial_value_edit: `{old: item.get("${name}")}`,
-    pre_edit: `const ${tempname} = data.["${name}"]?.new || data.["${name}"]?.old;
-				if(!${tempname}){
-				    throw new Error("Missing field: ${name}")
-         		}`,
-    fallback_value_sealious: "null",
-    ...is_required ? { main_value_sealious: tempname } : {}
-  };
-};
-export {
-  file_handler
-};
-//# sourceMappingURL=file.js.map