@multiplatform.one/backoffice 7.34.3 → 7.35.0

package/src/formBuilder/api.spec.ts

@@ -0,0 +1,301 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { createHttpClient } from "../form/formActions";
+import {
+  buildCustomizeFormPayload,
+  buildDoctypeSavePayload,
+  formBuilderFields,
+  formBuilderMode,
+  loadFormBuilderSource,
+  parseFormBuilderError,
+  saveFormBuilderLayout,
+  type FormBuilderSource,
+} from "./api";
+import {
+  fieldsFromLayout,
+  insertField,
+  layoutFromFields,
+  moveField,
+  newFieldFromType,
+  updateField,
+} from "./model";
+
+const source: FormBuilderSource = {
+  doctype: "Customize Form",
+  name: "Customize Form",
+  doc_type: "Pokemon",
+  modified: "yesterday",
+  track_changes: 1,
+  fields: [
+    {
+      fieldname: "pokemon_name",
+      fieldtype: "Data",
+      label: "Pokemon Name",
+      name: "row-a",
+      permlevel: 2,
+      fetch_from: "link.name",
+      custom_property: "preserve me",
+    },
+    { fieldname: "column_break_1", fieldtype: "Column Break", name: "row-b", width: "50%" },
+    { fieldname: "species", fieldtype: "Data", label: "Species", name: "row-c", hidden: 0 },
+  ],
+};
+const http = () => createHttpClient({ baseURL: "https://builder.spec.test" });
+const response = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function editedLayout() {
+  const layout = layoutFromFields(source.fields);
+  const [first, second] = layout.tabs[0].sections[0].columns;
+  const moved = moveField(layout, second.fields[0].key, { columnId: first.key, index: 0 });
+  const added = insertField(moved, newFieldFromType(moved, "Data"), {
+    columnId: first.key,
+    index: 1,
+  });
+  return updateField(added.layout, added.key, { label: "Nickname", reqd: 1 });
+}
+
+describe("form builder persistence", () => {
+  it("uses Customize Form for standard DocTypes and the document for custom ones", () => {
+    expect(formBuilderMode({ custom: 0 })).toBe("customize");
+    expect(formBuilderMode({})).toBe("customize");
+    expect(formBuilderMode({ custom: 1 })).toBe("doctype");
+  });
+
+  it("lays out a custom DocType's own rows and every row through Customize Form", () => {
+    const fields = [
+      { fieldname: "title", fieldtype: "Data" },
+      { fieldname: "extra", fieldtype: "Data", is_custom_field: 1 },
+    ];
+    expect(formBuilderFields({ custom: 1, fields }).map((df) => df.fieldname)).toEqual(["title"]);
+    expect(formBuilderFields({ custom: 0, fields }).map((df) => df.fieldname)).toEqual([
+      "title",
+      "extra",
+    ]);
+  });
+
+  it("fetches then saves Customize Form with reordered rows and new custom fields", async () => {
+    const requests: { url: string; body: URLSearchParams; contentType: string | null }[] = [];
+    vi.stubGlobal("fetch", async (url: string, init: RequestInit) => {
+      const body = new URLSearchParams(String(init.body));
+      requests.push({ url, body, contentType: new Headers(init.headers).get("content-type") });
+      return response(
+        body.get("method") === "fetch_to_customize"
+          ? { docs: [source] }
+          : { docs: [JSON.parse(body.get("docs")!)] },
+      );
+    });
+    const client = http();
+    const loaded = await loadFormBuilderSource(client, "Pokemon", "customize");
+    expect(loaded).toEqual(source);
+    const layout = editedLayout();
+    const fields = await saveFormBuilderLayout({
+      http: client,
+      doctype: "Pokemon",
+      mode: "customize",
+      source: loaded,
+      layout,
+    });
+    expect(requests.map((r) => new URL(r.url).pathname)).toEqual([
+      "/api/method/run_doc_method",
+      "/api/method/run_doc_method",
+    ]);
+    expect(requests.map((r) => r.body.get("method"))).toEqual([
+      "fetch_to_customize",
+      "save_customization",
+    ]);
+    expect(requests.every((r) => r.contentType === "application/x-www-form-urlencoded")).toBe(true);
+    expect(JSON.parse(requests[0].body.get("docs")!)).toEqual({
+      doctype: "Customize Form",
+      name: "Customize Form",
+      doc_type: "Pokemon",
+    });
+    const payload = JSON.parse(requests[1].body.get("docs")!);
+    expect(payload).toEqual(buildCustomizeFormPayload(source, layout));
+    expect(payload.modified).toBe("yesterday");
+    expect(fields.map((f) => [f.fieldname, f.idx])).toEqual([
+      ["species", 1],
+      ["nickname", 2],
+      ["pokemon_name", 3],
+      ["column_break_1", 4],
+    ]);
+    expect(fields[2]).toMatchObject(source.fields[0]);
+    expect(fields[3]).toMatchObject(source.fields[1]);
+    expect(fields[1]).toEqual({
+      fieldtype: "Data",
+      fieldname: "nickname",
+      label: "Nickname",
+      reqd: 1,
+      idx: 2,
+      doctype: "Customize Form Field",
+      parenttype: "Customize Form",
+      parentfield: "fields",
+      parent: "Customize Form",
+      is_custom_field: 1,
+      __islocal: 1,
+    });
+    expect(fields.every((f) => !("key" in f) && !("isNew" in f) && !("fieldnameEdited" in f))).toBe(
+      true,
+    );
+    expect(source.fields[0].idx).toBeUndefined();
+  });
+
+  it("merges source-only properties before builder edits", () => {
+    const layout = layoutFromFields(
+      source.fields.map(({ fieldname, fieldtype }) => ({ fieldname, fieldtype })),
+    );
+    const field = layout.tabs[0].sections[0].columns[0].fields[0];
+    const payload = buildCustomizeFormPayload(
+      source,
+      updateField(layout, field.key, { hidden: 1 }),
+    );
+    expect(payload.fields[0]).toMatchObject({ ...source.fields[0], hidden: 1 });
+  });
+
+  it("loads a custom DocType and saves DocField names through savedocs", async () => {
+    const doc = { ...source, name: "Pokemon", doctype: "DocType", custom: 1 };
+    const requests: { url: string; init: RequestInit }[] = [];
+    vi.stubGlobal("fetch", async (url: string, init: RequestInit) => {
+      requests.push({ url, init });
+      if (url.endsWith("frappe.client.get")) return response({ message: doc });
+      const body = new URLSearchParams(String(init.body));
+      const saved = JSON.parse(body.get("doc")!);
+      saved.fields[1].name = "server-issued";
+      return response({ docs: [saved] });
+    });
+    const client = http();
+    const loaded = await loadFormBuilderSource(client, "Pokemon", "doctype");
+    const fields = await saveFormBuilderLayout({
+      http: client,
+      doctype: "Pokemon",
+      mode: "doctype",
+      source: loaded,
+      layout: editedLayout(),
+    });
+    expect(JSON.parse(String(requests[0].init.body))).toEqual({
+      doctype: "DocType",
+      name: "Pokemon",
+    });
+    expect(new URL(requests[1].url).pathname).toBe("/api/method/frappe.desk.form.save.savedocs");
+    const body = new URLSearchParams(String(requests[1].init.body));
+    expect(body.get("action")).toBe("Save");
+    const payload = JSON.parse(body.get("doc")!);
+    expect(payload).toEqual(buildDoctypeSavePayload(doc, "Pokemon", editedLayout()));
+    expect(payload.fields[0].name).toBe("row-c");
+    expect(payload.fields[1]).toMatchObject({
+      doctype: "DocField",
+      parenttype: "DocType",
+      parent: "Pokemon",
+      parentfield: "fields",
+      __islocal: 1,
+      idx: 2,
+    });
+    expect(payload.fields[1]).not.toHaveProperty("name");
+    expect(fields[1].name).toBe("server-issued");
+  });
+
+  it("falls back to posted fields when save_customization returns no document", async () => {
+    vi.stubGlobal("fetch", async () => response({ message: null }));
+    const layout = editedLayout();
+    expect(
+      await saveFormBuilderLayout({
+        http: http(),
+        doctype: "Pokemon",
+        mode: "customize",
+        source,
+        layout,
+      }),
+    ).toEqual(buildCustomizeFormPayload(source, layout).fields);
+  });
+
+  it("rejects missing load or saved DocType documents", async () => {
+    vi.stubGlobal("fetch", async () => response({}));
+    await expect(loadFormBuilderSource(http(), "Pokemon", "customize")).rejects.toThrow("document");
+    await expect(loadFormBuilderSource(http(), "Pokemon", "doctype")).rejects.toThrow("document");
+    await expect(
+      saveFormBuilderLayout({
+        http: http(),
+        doctype: "Pokemon",
+        mode: "doctype",
+        source,
+        layout: editedLayout(),
+      }),
+    ).rejects.toThrow("document");
+  });
+
+  it("rejects a 417 and maps its fieldname or label into inline errors", async () => {
+    vi.stubGlobal("fetch", async () =>
+      response(
+        {
+          exc_type: "ValidationError",
+          _server_messages: JSON.stringify([
+            JSON.stringify({ message: "Fieldname <b>nickname</b> appears multiple times" }),
+          ]),
+        },
+        417,
+      ),
+    );
+    const layout = editedLayout();
+    let error: unknown;
+    try {
+      await saveFormBuilderLayout({
+        http: http(),
+        doctype: "Pokemon",
+        mode: "customize",
+        source,
+        layout,
+      });
+    } catch (err) {
+      error = err;
+    }
+    expect(error).toBeInstanceOf(Error);
+    expect(parseFormBuilderError(error, layout)).toEqual({
+      general: "Fieldname nickname appears multiple times",
+      fieldErrors: { nickname: "Fieldname nickname appears multiple times" },
+    });
+    expect(
+      parseFormBuilderError(new Error('Field "Pokemon Name" cannot be changed'), layout)
+        .fieldErrors,
+    ).toHaveProperty("pokemon_name");
+    expect(
+      parseFormBuilderError(new Error("Another nickname_extra exists"), layout).fieldErrors,
+    ).toEqual({});
+    expect(
+      parseFormBuilderError(
+        {
+          data: {
+            exc_type: "MandatoryError",
+            exception: "frappe.exceptions.MandatoryError: [Pokemon, new]: nickname",
+          },
+        },
+        layout,
+      ).fieldErrors,
+    ).toHaveProperty("nickname");
+  });
+
+  it("writes serialized fields to the fixture DocType without HTTP", async () => {
+    const fixtures = new InMemoryFixtureProvider({
+      DocType: [{ ...source, name: "Pokemon", doctype: "DocType" }],
+    });
+    const fetch = vi.fn();
+    vi.stubGlobal("fetch", fetch);
+    const layout = editedLayout();
+    const fields = await saveFormBuilderLayout({
+      fixtures,
+      doctype: "Pokemon",
+      mode: "customize",
+      source,
+      layout,
+    });
+    expect(fields).toEqual(fieldsFromLayout(layout));
+    expect((await fixtures.getDoc("DocType", "Pokemon"))?.fields).toEqual(fields);
+    expect(fetch).not.toHaveBeenCalled();
+    await expect(
+      saveFormBuilderLayout({ doctype: "Pokemon", mode: "customize", source, layout }),
+    ).rejects.toThrow("HTTP");
+  });
+});

package/src/formBuilder/api.ts

@@ -0,0 +1,198 @@
+import type { FixtureProvider, FrappeDocData, HttpClient } from "@multiplatform.one/frappe";
+import type { DoctypeMeta } from "@multiplatform.one/frappe-ui";
+import { parseServerError } from "../quickEntry/quickEntryPlan";
+import {
+  fieldsFromLayout,
+  type BuilderDocField,
+  type BuilderLayout,
+  type FormBuilderMode,
+} from "./model";
+
+export interface FormBuilderSource {
+  doctype: string;
+  name: string;
+  fields: BuilderDocField[];
+  [key: string]: unknown;
+}
+
+interface BuilderResponse {
+  docs?: FormBuilderSource[];
+  message?: FormBuilderSource;
+}
+
+export function formBuilderMode(meta: Partial<Pick<DoctypeMeta, "custom">>): FormBuilderMode {
+  return meta.custom ? "doctype" : "customize";
+}
+
+/** The rows the builder lays out: a custom DocType's document holds no Custom Field rows. */
+export function formBuilderFields(
+  meta: Partial<Pick<DoctypeMeta, "custom">> & { fields: readonly unknown[] },
+): BuilderDocField[] {
+  const fields = meta.fields as BuilderDocField[];
+  return formBuilderMode(meta) === "doctype" ? fields.filter((df) => !df.is_custom_field) : fields;
+}
+
+async function postForm(
+  http: HttpClient,
+  method: string,
+  body: Record<string, string>,
+): Promise<BuilderResponse> {
+  const response = await http.post<BuilderResponse>(`/api/method/${method}`, body, {
+    "Content-Type": "application/x-www-form-urlencoded",
+  });
+  return response.payload;
+}
+
+export async function loadFormBuilderSource(
+  http: HttpClient,
+  doctype: string,
+  mode: FormBuilderMode,
+): Promise<FormBuilderSource> {
+  let source: FormBuilderSource | undefined;
+  if (mode === "customize") {
+    const response = await postForm(http, "run_doc_method", {
+      docs: JSON.stringify({
+        doctype: "Customize Form",
+        name: "Customize Form",
+        doc_type: doctype,
+      }),
+      method: "fetch_to_customize",
+    });
+    source = response.docs?.[0];
+  } else {
+    const response = await http.post<BuilderResponse>("/api/method/frappe.client.get", {
+      doctype: "DocType",
+      name: doctype,
+    });
+    source = response.payload?.message;
+  }
+  if (!source || !Array.isArray(source.fields))
+    throw new Error(`No form builder source document returned for ${doctype}`);
+  return source;
+}
+
+function saveFields(
+  source: FormBuilderSource,
+  layout: BuilderLayout,
+  mode: FormBuilderMode,
+  parent: string,
+): BuilderDocField[] {
+  const existing = new Map(source.fields.map((df) => [df.fieldname, df]));
+  return fieldsFromLayout(layout).map((df) => {
+    const previous = existing.get(df.fieldname);
+    const row: BuilderDocField = {
+      ...previous,
+      ...df,
+      doctype: mode === "customize" ? "Customize Form Field" : "DocField",
+      parenttype: mode === "customize" ? "Customize Form" : "DocType",
+      parentfield: "fields",
+      parent,
+    };
+    if (previous) {
+      if (previous.name !== undefined) row.name = previous.name;
+    } else {
+      delete row.name;
+      row.__islocal = 1;
+      if (mode === "customize") row.is_custom_field = 1;
+    }
+    return row;
+  });
+}
+
+export function buildCustomizeFormPayload(
+  source: FormBuilderSource,
+  layout: BuilderLayout,
+): FormBuilderSource {
+  return {
+    ...source,
+    doctype: "Customize Form",
+    name: "Customize Form",
+    fields: saveFields(source, layout, "customize", "Customize Form"),
+  };
+}
+
+export function buildDoctypeSavePayload(
+  source: FormBuilderSource,
+  doctype: string,
+  layout: BuilderLayout,
+): FormBuilderSource {
+  return {
+    ...source,
+    doctype: "DocType",
+    name: doctype,
+    fields: saveFields(source, layout, "doctype", doctype),
+  };
+}
+
+export interface SaveFormBuilderLayoutOptions {
+  http?: HttpClient;
+  fixtures?: FixtureProvider;
+  doctype: string;
+  mode: FormBuilderMode;
+  source: FormBuilderSource;
+  layout: BuilderLayout;
+}
+
+export async function saveFormBuilderLayout({
+  http,
+  fixtures,
+  doctype,
+  mode,
+  source,
+  layout,
+}: SaveFormBuilderLayoutOptions): Promise<BuilderDocField[]> {
+  if (fixtures) {
+    const fields = fieldsFromLayout(layout);
+    await fixtures.updateDoc("DocType", doctype, { fields } as unknown as Partial<FrappeDocData>);
+    return fields;
+  }
+  if (!http)
+    throw new Error(
+      "An HTTP client or fixture provider is required to save the form builder layout",
+    );
+  if (mode === "customize") {
+    const doc = buildCustomizeFormPayload(source, layout);
+    const response = await postForm(http, "run_doc_method", {
+      docs: JSON.stringify(doc),
+      method: "save_customization",
+    });
+    // save_customization can succeed without returning the Customize Form document.
+    return response.docs?.[0]?.fields ?? doc.fields;
+  }
+  const doc = buildDoctypeSavePayload(source, doctype, layout);
+  const response = await postForm(http, "frappe.desk.form.save.savedocs", {
+    doc: JSON.stringify(doc),
+    action: "Save",
+  });
+  const saved = response.docs?.[0];
+  if (!saved || !Array.isArray(saved.fields))
+    throw new Error(`No saved DocType document returned for ${doctype}`);
+  return saved.fields;
+}
+
+export interface FormBuilderError {
+  general?: string;
+  fieldErrors: Record<string, string>;
+}
+
+function mentions(message: string, value: string): boolean {
+  const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[^a-zA-Z0-9_])${escaped}($|[^a-zA-Z0-9_])`, "i").test(message);
+}
+
+export function parseFormBuilderError(err: unknown, layout: BuilderLayout): FormBuilderError {
+  const parsed = parseServerError(err, "Unable to save the form layout.");
+  const general =
+    parsed.general ?? (parsed.missingFields.length ? "Required fields are missing." : undefined);
+  const fieldErrors: Record<string, string> = {};
+  for (const df of fieldsFromLayout(layout)) {
+    if (!df.fieldname) continue;
+    if (
+      parsed.missingFields.includes(df.fieldname) ||
+      (general && (mentions(general, df.fieldname) || (df.label && mentions(general, df.label))))
+    ) {
+      fieldErrors[df.fieldname] = general ?? "This field is required.";
+    }
+  }
+  return { general, fieldErrors };
+}

package/src/formBuilder/fieldtypes.ts

@@ -0,0 +1,140 @@
+export interface BuilderMessage {
+  key: string;
+  default: string;
+}
+
+export interface BuilderFieldtype {
+  fieldtype: string;
+  group: "standard" | "layout" | "advanced";
+  labelKey: string;
+  label: string;
+  descriptionKey: string;
+  description: string;
+}
+
+const groups: Record<BuilderFieldtype["group"], [string, string][]> = {
+  standard: [
+    ["Data", "Single line text"],
+    ["Text", "Multi-line text"],
+    ["Small Text", "Short text block"],
+    ["Long Text", "Long text block"],
+    ["Text Editor", "Rich text"],
+    ["Int", "Whole number"],
+    ["Float", "Decimal number"],
+    ["Currency", "Money amount"],
+    ["Percent", "Percentage"],
+    ["Check", "Yes or no"],
+    ["Select", "Fixed choice list"],
+    ["Link", "Linked document"],
+    ["Date", "Calendar date"],
+    ["Datetime", "Date and time"],
+    ["Time", "Time of day"],
+    ["Duration", "Elapsed time"],
+    ["Attach", "File upload"],
+    ["Attach Image", "Image upload"],
+    ["Phone", "Phone number"],
+    ["Password", "Hidden secret"],
+    ["Rating", "Star rating"],
+  ],
+  layout: [
+    ["Tab Break", "New form tab"],
+    ["Section Break", "New section"],
+    ["Column Break", "New column"],
+    ["Heading", "Heading text"],
+    ["HTML", "Static HTML"],
+    ["Image", "Image from a field"],
+    ["Button", "Form action"],
+    ["Fold", "Fold point"],
+    ["Attachment Gallery", "Attachment gallery"],
+  ],
+  advanced: [
+    ["Autocomplete", "Suggested text"],
+    ["Barcode", "Scannable code"],
+    ["Code", "Source code"],
+    ["Color", "Colour picker"],
+    ["Dynamic Link", "Link by field"],
+    ["Geolocation", "Map location"],
+    ["HTML Editor", "Editable HTML"],
+    ["Icon", "Icon picker"],
+    ["JSON", "JSON data"],
+    ["Markdown Editor", "Markdown text"],
+    ["Read Only", "Display value"],
+    ["Signature", "Drawn signature"],
+    ["Table", "Child table"],
+    ["Table MultiSelect", "Multi-link table"],
+  ],
+};
+
+export const fieldtypeCatalog: readonly BuilderFieldtype[] = Object.entries(groups).flatMap(
+  ([group, entries]) =>
+    entries.map(([fieldtype, description]) => {
+      const id = fieldtype.toLowerCase().replaceAll(" ", "_");
+      return {
+        fieldtype,
+        group: group as BuilderFieldtype["group"],
+        labelKey: `formBuilder.fieldtypes.${id}.label`,
+        label: fieldtype,
+        descriptionKey: `formBuilder.fieldtypes.${id}.description`,
+        description,
+      };
+    }),
+);
+
+export const isTabBreak = (fieldtype: string) => fieldtype === "Tab Break";
+export const isSectionBreak = (fieldtype: string) => fieldtype === "Section Break";
+export const isColumnBreak = (fieldtype: string) => fieldtype === "Column Break";
+export const isBreakType = (fieldtype: string) =>
+  isTabBreak(fieldtype) || isSectionBreak(fieldtype) || isColumnBreak(fieldtype);
+
+export function optionsHint(fieldtype: string): BuilderMessage | undefined {
+  switch (fieldtype) {
+    case "Link":
+      return { key: "formBuilder.options.link", default: "The target DocType name." };
+    case "Dynamic Link":
+      return {
+        key: "formBuilder.options.dynamicLink",
+        default: "The fieldname of the field containing the target DocType.",
+      };
+    case "Table":
+    case "Table MultiSelect":
+      return { key: "formBuilder.options.table", default: "The child DocType name." };
+    case "Select":
+    case "Autocomplete":
+      return { key: "formBuilder.options.select", default: "One option per line." };
+    case "Data":
+      return {
+        key: "formBuilder.options.data",
+        default: "Optional format, such as Email, Phone or URL.",
+      };
+    case "Code":
+      return {
+        key: "formBuilder.options.code",
+        default: "The syntax language, such as Python or JavaScript.",
+      };
+    case "HTML":
+      return { key: "formBuilder.options.html", default: "The HTML content to display." };
+    case "Image":
+      return {
+        key: "formBuilder.options.image",
+        default: "The fieldname containing the image URL.",
+      };
+    case "Currency":
+      return {
+        key: "formBuilder.options.currency",
+        default: "The fieldname containing the currency.",
+      };
+    case "Read Only":
+      return {
+        key: "formBuilder.options.readOnly",
+        default: "The fieldname whose value is displayed.",
+      };
+    default:
+      return undefined;
+  }
+}
+
+export const needsOptions = (fieldtype: string) =>
+  ["Link", "Dynamic Link", "Table", "Table MultiSelect", "Select"].includes(fieldtype);
+export const holdsValue = (fieldtype: string) =>
+  !isBreakType(fieldtype) &&
+  !["HTML", "Heading", "Button", "Image", "Fold", "Attachment Gallery"].includes(fieldtype);

package/src/formBuilder/index.ts

@@ -0,0 +1,58 @@
+export {
+  fieldtypeCatalog,
+  holdsValue,
+  isBreakType,
+  isColumnBreak,
+  isSectionBreak,
+  isTabBreak,
+  needsOptions,
+  optionsHint,
+  type BuilderFieldtype,
+  type BuilderMessage,
+} from "./fieldtypes";
+export {
+  addColumn,
+  addSection,
+  addTab,
+  canDeleteField,
+  fieldLocation,
+  fieldsFromLayout,
+  findField,
+  insertField,
+  layoutFromFields,
+  moveField,
+  moveFieldBy,
+  moveFieldToSection,
+  newFieldFromType,
+  removeColumn,
+  removeField,
+  removeSection,
+  removeTab,
+  scrub,
+  tabBoard,
+  updateBreak,
+  updateField,
+  validateLayout,
+  type BuilderColumn,
+  type BuilderDocField,
+  type BuilderField,
+  type BuilderFieldLocation,
+  type BuilderLayout,
+  type BuilderSection,
+  type BuilderTab,
+  type FormBuilderMode,
+} from "./model";
+export {
+  buildCustomizeFormPayload,
+  buildDoctypeSavePayload,
+  formBuilderFields,
+  formBuilderMode,
+  loadFormBuilderSource,
+  parseFormBuilderError,
+  saveFormBuilderLayout,
+  type FormBuilderError,
+  type FormBuilderSource,
+  type SaveFormBuilderLayoutOptions,
+} from "./api";
+
+export { FormBuilderScreen, type FormBuilderScreenProps } from "./FormBuilderScreen";