best-lowcode-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1130 @@
+// src/lowcode/BestCrudPage.tsx
+import { Button as Button4, Modal as Modal2, message } from "antd";
+import dayjs3 from "dayjs";
+import { useCallback, useEffect as useEffect3, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+
+// src/runtime/BestProvider.tsx
+import { ConfigProvider } from "antd";
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var emptyRegistry = {
+  listServices: {},
+  services: {},
+  dictionaries: {},
+  actions: {},
+  slots: {},
+  access: () => true
+};
+var defaultTheme = {
+  token: {
+    borderRadius: 6,
+    controlHeight: 32,
+    fontSize: 14
+  }
+};
+var BestRuntimeContext = createContext(emptyRegistry);
+function createBestRegistry(registry = {}) {
+  return {
+    listServices: registry.listServices ?? {},
+    services: registry.services ?? {},
+    dictionaries: registry.dictionaries ?? {},
+    actions: registry.actions ?? {},
+    slots: registry.slots ?? {},
+    access: registry.access ?? emptyRegistry.access
+  };
+}
+function BestProvider({ children, registry, theme }) {
+  const value = useMemo(() => createBestRegistry(registry), [registry]);
+  const mergedTheme = useMemo(
+    () => ({ ...defaultTheme, ...theme, token: { ...defaultTheme.token, ...theme?.token } }),
+    [theme]
+  );
+  return /* @__PURE__ */ jsx(BestRuntimeContext.Provider, { value, children: /* @__PURE__ */ jsx(ConfigProvider, { theme: mergedTheme, children }) });
+}
+function useBestRegistry() {
+  return useContext(BestRuntimeContext);
+}
+function useBestService(key) {
+  const service = useBestRegistry().services[key];
+  if (!service) throw new Error(`\u672A\u6CE8\u518C\u670D\u52A1\uFF1A${key}`);
+  return service;
+}
+function useBestListService(key) {
+  return useBestRegistry().listServices[key];
+}
+function useBestAccess(key) {
+  const registry = useBestRegistry();
+  return key ? registry.access(key) : true;
+}
+function useBestDictionary(key) {
+  const dictionaries = useBestRegistry().dictionaries;
+  return key ? dictionaries[key] ?? [] : [];
+}
+function useBestAction(key) {
+  const action = useBestRegistry().actions[key];
+  if (!action) throw new Error(`\u672A\u6CE8\u518C\u52A8\u4F5C\uFF1A${key}`);
+  return action;
+}
+
+// src/ui/BestBatchInput.tsx
+import { Input } from "antd";
+import { useImperativeHandle, useMemo as useMemo2, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function parse(value, separator) {
+  const escaped = separator.replace(/[\\\]\-^]/g, "\\$&");
+  const delimiter = new RegExp(`[${escaped}]`);
+  return value.split("\n").map((row) => row.trim()).filter(Boolean).map((row) => row.split(delimiter).map((cell) => cell.trim()));
+}
+function BestBatchInput({
+  ref,
+  separator = "|",
+  value,
+  defaultValue,
+  onChange,
+  ...props
+}) {
+  const [innerValue, setInnerValue] = useState(String(defaultValue ?? ""));
+  const currentValue = value == null ? innerValue : String(value);
+  const parsed = useMemo2(() => parse(currentValue, separator), [currentValue, separator]);
+  useImperativeHandle(ref, () => ({ getParsedValue: () => parsed }), [parsed]);
+  return /* @__PURE__ */ jsx2(
+    Input.TextArea,
+    {
+      ...props,
+      value: currentValue,
+      onChange: (event) => {
+        const nextValue = event.target.value;
+        if (value == null) setInnerValue(nextValue);
+        onChange?.(nextValue, parse(nextValue, separator));
+      }
+    }
+  );
+}
+
+// src/ui/BestDetail.tsx
+import { Descriptions } from "antd";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function BestDetail({ fields, record = {}, column = 2 }) {
+  return /* @__PURE__ */ jsx3(Descriptions, { bordered: true, column, size: "small", children: fields.map((field) => {
+    const value = record[field.field];
+    const display = field.render ? field.render(value, record) : field.valueEnum?.[String(value)] ?? (value == null || value === "" ? "-" : String(value));
+    return /* @__PURE__ */ jsx3(Descriptions.Item, { label: field.label, span: field.span, children: display }, field.field);
+  }) });
+}
+
+// src/ui/BestFilePreview.tsx
+import { Button, Image, List, Typography } from "antd";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+function isImage(file) {
+  return file.mimeType?.startsWith("image/") || /\.(avif|bmp|gif|jpe?g|png|svg|webp)(?:$|[?#])/i.test(file.url);
+}
+function BestFilePreview({ files, onDownload }) {
+  return /* @__PURE__ */ jsx4(
+    List,
+    {
+      dataSource: files,
+      renderItem: (file) => /* @__PURE__ */ jsxs(
+        List.Item,
+        {
+          actions: [
+            /* @__PURE__ */ jsx4(Button, { type: "link", onClick: () => onDownload?.(file), children: "\u4E0B\u8F7D" }, "download")
+          ],
+          children: [
+            isImage(file) ? /* @__PURE__ */ jsx4(Image, { alt: file.name ?? "\u6587\u4EF6\u9884\u89C8", height: 48, preview: true, src: file.url, width: 48 }) : null,
+            /* @__PURE__ */ jsx4(Typography.Text, { ellipsis: true, style: { marginInlineStart: isImage(file) ? 12 : 0 }, children: file.name ?? file.url })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/ui/BestForm.tsx
+import { Button as Button2, DatePicker, Form, Input as Input2, InputNumber, Select, Space } from "antd";
+import { useEffect } from "react";
+import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function FormControl({
+  field,
+  values,
+  mode = "create",
+  form,
+  ...controlProps
+}) {
+  switch (field.component) {
+    case "select":
+      return /* @__PURE__ */ jsx5(
+        Select,
+        {
+          ...controlProps,
+          disabled: field.disabled,
+          options: field.options,
+          placeholder: field.placeholder
+        }
+      );
+    case "number":
+      return /* @__PURE__ */ jsx5(
+        InputNumber,
+        {
+          ...controlProps,
+          disabled: field.disabled,
+          placeholder: field.placeholder,
+          style: { width: "100%" }
+        }
+      );
+    case "date":
+      return /* @__PURE__ */ jsx5(DatePicker, { ...controlProps, disabled: field.disabled, style: { width: "100%" } });
+    case "dateRange":
+      return /* @__PURE__ */ jsx5(
+        DatePicker.RangePicker,
+        {
+          ...controlProps,
+          disabled: field.disabled,
+          style: { width: "100%" }
+        }
+      );
+    case "textarea":
+      return /* @__PURE__ */ jsx5(
+        Input2.TextArea,
+        {
+          ...controlProps,
+          disabled: field.disabled,
+          placeholder: field.placeholder
+        }
+      );
+    case "slot":
+      return /* @__PURE__ */ jsx5(Fragment, { children: field.render?.({
+        field: field.field,
+        values,
+        value: values[field.field],
+        mode,
+        disabled: field.disabled,
+        setValue: (name, value) => form.setFieldValue(name, value)
+      }) });
+    case "repeatable":
+      return /* @__PURE__ */ jsx5(Form.List, { name: field.field, children: (items, { add, remove }) => /* @__PURE__ */ jsxs2(Fragment, { children: [
+        items.map((item) => /* @__PURE__ */ jsxs2(Space, { align: "start", children: [
+          field.itemFields?.map((itemField) => /* @__PURE__ */ jsx5(
+            Form.Item,
+            {
+              label: itemField.label,
+              name: [item.name, itemField.field],
+              rules: itemField.rules,
+              children: /* @__PURE__ */ jsx5(FormControl, { field: itemField, form, mode, values })
+            },
+            itemField.field
+          )),
+          /* @__PURE__ */ jsx5(
+            Button2,
+            {
+              disabled: items.length <= (field.minItems ?? 0),
+              onClick: () => remove(item.name),
+              type: "link",
+              children: "\u5220\u9664"
+            }
+          )
+        ] }, item.key)),
+        /* @__PURE__ */ jsx5(
+          Button2,
+          {
+            disabled: Boolean(field.maxItems && items.length >= field.maxItems),
+            onClick: () => add(),
+            type: "dashed",
+            children: "\u65B0\u589E\u4E00\u9879"
+          }
+        )
+      ] }) });
+    default:
+      return /* @__PURE__ */ jsx5(Input2, { ...controlProps, disabled: field.disabled, placeholder: field.placeholder });
+  }
+}
+function FormFields({ fields, form, initialValues, mode = "create" }) {
+  const values = Form.useWatch([], { form, preserve: true }) ?? initialValues ?? {};
+  const isVisible = (field) => !field.hidden && (!field.visibleWhen || evaluateCondition(field.visibleWhen, values, mode));
+  useEffect(() => {
+    fields.filter((field) => field.clearWhenHidden && !isVisible(field)).forEach((field) => {
+      if (values[field.field] !== void 0) form.setFieldValue(field.field, void 0);
+    });
+  }, [fields, form, mode, values]);
+  return /* @__PURE__ */ jsx5(Fragment, { children: fields.filter((field) => isVisible(field)).map((field) => {
+    const control = /* @__PURE__ */ jsx5(
+      FormControl,
+      {
+        field: {
+          ...field,
+          disabled: field.disabled || Boolean(field.disabledWhen && evaluateCondition(field.disabledWhen, values, mode))
+        },
+        form,
+        mode,
+        values
+      },
+      field.field
+    );
+    return field.component === "repeatable" ? /* @__PURE__ */ jsx5(Form.Item, { label: field.label, children: control }, field.field) : /* @__PURE__ */ jsx5(Form.Item, { label: field.label, name: field.field, rules: field.rules, children: control }, field.field);
+  }) });
+}
+function BestForm({
+  fields,
+  initialValues,
+  loading,
+  submitText = "\u63D0\u4EA4",
+  extra,
+  mode,
+  onSubmit,
+  onCancel
+}) {
+  const [form] = Form.useForm();
+  return /* @__PURE__ */ jsxs2(Form, { form, initialValues, layout: "vertical", onFinish: onSubmit, children: [
+    /* @__PURE__ */ jsx5(FormFields, { fields, form, initialValues, mode }),
+    /* @__PURE__ */ jsxs2(Space, { children: [
+      /* @__PURE__ */ jsx5(Button2, { htmlType: "submit", loading, type: "primary", children: submitText }),
+      onCancel ? /* @__PURE__ */ jsx5(Button2, { onClick: onCancel, children: "\u53D6\u6D88" }) : null,
+      extra
+    ] })
+  ] });
+}
+function evaluateCondition(condition, values, mode) {
+  switch (condition.operator) {
+    case "equals":
+      return values[condition.field] === condition.value;
+    case "notEmpty":
+      return values[condition.field] !== void 0 && values[condition.field] !== null && values[condition.field] !== "";
+    case "modeEquals":
+      return mode === condition.value;
+    case "and":
+      return condition.conditions.every((item) => evaluateCondition(item, values, mode));
+    case "or":
+      return condition.conditions.some((item) => evaluateCondition(item, values, mode));
+    case "not":
+      return !evaluateCondition(condition.condition, values, mode);
+  }
+}
+
+// src/ui/BestLightTable.tsx
+import { Table } from "antd";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function BestLightTable({
+  columns,
+  data,
+  rowKey
+}) {
+  const tableColumns = columns.map((column) => ({
+    dataIndex: column.field,
+    key: column.field,
+    title: column.title,
+    width: column.width,
+    render: column.render
+  }));
+  return /* @__PURE__ */ jsx6(
+    Table,
+    {
+      columns: tableColumns,
+      dataSource: data,
+      pagination: false,
+      rowKey,
+      size: "small"
+    }
+  );
+}
+
+// src/ui/BestOverlay.tsx
+import { Drawer, Modal } from "antd";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function BestDrawer({ children, open, title, onClose }) {
+  return /* @__PURE__ */ jsx7(Drawer, { destroyOnHidden: true, open, title, width: 640, onClose, children });
+}
+function BestModal({ children, open, title, onClose }) {
+  return /* @__PURE__ */ jsx7(Modal, { destroyOnHidden: true, footer: null, open, title, onCancel: onClose, children });
+}
+
+// src/ui/BestSearch.tsx
+import { Button as Button3, Col, DatePicker as DatePicker2, Form as Form2, Input as Input3, InputNumber as InputNumber2, Row, Select as Select2 } from "antd";
+import dayjs from "dayjs";
+import { useEffect as useEffect2 } from "react";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+function FieldControl({ field }) {
+  switch (field.component) {
+    case "select":
+      return /* @__PURE__ */ jsx8(
+        Select2,
+        {
+          allowClear: true,
+          disabled: field.disabled,
+          options: field.options,
+          placeholder: field.placeholder
+        }
+      );
+    case "number":
+      return /* @__PURE__ */ jsx8(
+        InputNumber2,
+        {
+          disabled: field.disabled,
+          placeholder: field.placeholder,
+          style: { width: "100%" }
+        }
+      );
+    case "date":
+      return /* @__PURE__ */ jsx8(
+        DatePicker2,
+        {
+          disabled: field.disabled,
+          disabledDate: (current) => field.maxDate === "today" && current.isAfter(dayjs(), "day"),
+          placeholder: field.placeholder,
+          style: { width: "100%" }
+        }
+      );
+    case "dateRange":
+      return /* @__PURE__ */ jsx8(
+        DatePicker2.RangePicker,
+        {
+          disabled: field.disabled,
+          disabledDate: (current) => field.maxDate === "today" && current.isAfter(dayjs(), "day"),
+          style: { width: "100%" }
+        }
+      );
+    case "textarea":
+      return /* @__PURE__ */ jsx8(Input3.TextArea, { disabled: field.disabled, placeholder: field.placeholder });
+    default:
+      return /* @__PURE__ */ jsx8(Input3, { allowClear: true, disabled: field.disabled, placeholder: field.placeholder });
+  }
+}
+function syncValues(form, value) {
+  form.setFieldsValue(value ?? {});
+}
+function BestSearch({
+  fields,
+  value,
+  loading,
+  submitText = "\u67E5\u8BE2",
+  extra,
+  onChange,
+  onSearch,
+  onReset
+}) {
+  const [form] = Form2.useForm();
+  useEffect2(() => {
+    syncValues(form, value);
+  }, [form, value]);
+  return /* @__PURE__ */ jsx8(
+    Form2,
+    {
+      form,
+      layout: "vertical",
+      onFinish: (values) => onSearch(values),
+      onValuesChange: (_, values) => onChange?.(values),
+      style: { marginBottom: 16 },
+      children: /* @__PURE__ */ jsxs3(Row, { gutter: 16, align: "bottom", children: [
+        fields.filter((field) => !field.hidden).map((field) => /* @__PURE__ */ jsx8(Col, { span: field.span ?? 6, children: /* @__PURE__ */ jsx8(Form2.Item, { label: field.label, name: field.field, rules: field.rules, children: /* @__PURE__ */ jsx8(FieldControl, { field }) }) }, field.field)),
+        /* @__PURE__ */ jsx8(Col, { children: /* @__PURE__ */ jsxs3(Form2.Item, { children: [
+          /* @__PURE__ */ jsx8(Button3, { htmlType: "submit", loading, type: "primary", children: submitText }),
+          /* @__PURE__ */ jsx8(
+            Button3,
+            {
+              onClick: () => {
+                form.resetFields();
+                onChange?.({});
+                onReset?.();
+              },
+              style: { marginInlineStart: 8 },
+              children: "\u91CD\u7F6E"
+            }
+          ),
+          extra
+        ] }) })
+      ] })
+    }
+  );
+}
+
+// src/ui/BestStates.tsx
+import { Empty, Result, Spin } from "antd";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function BestLoading({ description = "\u52A0\u8F7D\u4E2D" }) {
+  return /* @__PURE__ */ jsx9("div", { style: { display: "grid", minHeight: 160, placeItems: "center" }, children: /* @__PURE__ */ jsx9(Spin, { tip: description }) });
+}
+function BestEmpty({ description = "\u6682\u65E0\u6570\u636E" }) {
+  return /* @__PURE__ */ jsx9(Empty, { description });
+}
+function BestError({ description = "\u52A0\u8F7D\u5931\u8D25" }) {
+  return /* @__PURE__ */ jsx9(Result, { status: "error", title: description });
+}
+
+// src/ui/BestTable.tsx
+import {
+  ProTable
+} from "@ant-design/pro-components";
+
+// src/ui/BestTable.module.less
+var BestTable_module_default = {};
+
+// src/ui/BestTable.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var defaultSearch = {
+  layout: "vertical",
+  labelWidth: "auto",
+  defaultCollapsed: false,
+  collapseRender: false,
+  span: 6
+};
+function mergeSearch(defaults, value) {
+  if (value === false) return false;
+  return { ...defaults, ...value ?? {} };
+}
+function BestTable({
+  columns,
+  cardProps,
+  className,
+  search,
+  emptyText = "\u6682\u65E0\u6570\u636E",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx10(
+    ProTable,
+    {
+      ...props,
+      className: [BestTable_module_default.root, className].filter(Boolean).join(" "),
+      columns,
+      options: false,
+      search: mergeSearch(defaultSearch, search),
+      cardProps: cardProps === false ? false : {
+        ...cardProps,
+        styles: {
+          ...cardProps?.styles,
+          body: { ...cardProps?.styles?.body, padding: 12 }
+        }
+      },
+      locale: { emptyText }
+    }
+  );
+}
+
+// src/lowcode/runtime.ts
+import dayjs2 from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+dayjs2.extend(utc);
+function toBestListQuery(params, sort) {
+  const { current, pageSize, ...filters } = params;
+  const normalizedSort = Object.fromEntries(
+    Object.entries(sort ?? {}).filter(
+      (entry) => entry[1] === "ascend" || entry[1] === "descend"
+    )
+  );
+  return {
+    page: typeof current === "number" && current > 0 ? current : 1,
+    pageSize: typeof pageSize === "number" && pageSize > 0 ? pageSize : 20,
+    filters,
+    ...Object.keys(normalizedSort).length ? { sort: normalizedSort } : {}
+  };
+}
+function formatCrudValue(value, format) {
+  if (value == null || value === "") return "-";
+  if (!format || format === "text") return String(value);
+  if (format === "money") {
+    const amount = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(amount) ? new Intl.NumberFormat("zh-CN", {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }).format(amount) : String(value);
+  }
+  if (typeof value !== "string" && typeof value !== "number" && !(value instanceof Date)) {
+    return String(value);
+  }
+  let timestamp = value;
+  if (typeof value === "number" || typeof value === "string") {
+    const numericValue = typeof value === "number" ? value : Number(value.trim());
+    timestamp = Number.isFinite(numericValue) && numericValue !== 0 ? Math.abs(numericValue) >= 1e12 ? numericValue : numericValue * 1e3 : value;
+  }
+  const date = dayjs2.utc(timestamp);
+  if (!date.isValid()) return String(value);
+  return date.format(format === "date" ? "YYYY-MM-DD" : "YYYY-MM-DD HH:mm:ss");
+}
+function errorMessage(error, fallback) {
+  return error instanceof Error && error.message.trim() ? error.message : fallback;
+}
+function isAbortError(error, signal) {
+  return signal?.aborted || error instanceof DOMException && error.name === "AbortError";
+}
+async function confirmBeforeAction(content, confirm) {
+  return !content || confirm(content);
+}
+async function removeCrudRecord(record, service, content, confirm) {
+  if (!await confirmBeforeAction(content, confirm)) return false;
+  await service(record);
+  return true;
+}
+function createLatestPageRequest(service, onError) {
+  let sequence = 0;
+  let controller;
+  let latest = { data: [], success: false, total: 0 };
+  return {
+    async request(query) {
+      controller?.abort();
+      controller = new AbortController();
+      const currentController = controller;
+      const currentSequence = ++sequence;
+      try {
+        const response = await service(query, { signal: currentController.signal });
+        const pageResponse = {
+          data: response.items,
+          success: true,
+          total: response.total
+        };
+        if (currentSequence !== sequence) return latest;
+        latest = pageResponse;
+        return pageResponse;
+      } catch (error) {
+        if (currentSequence !== sequence || isAbortError(error, currentController.signal))
+          return latest;
+        onError(error);
+        return { data: [], success: false, total: 0 };
+      }
+    },
+    abort() {
+      controller?.abort();
+    }
+  };
+}
+
+// src/lowcode/schema.ts
+var CRUD_SCHEMA_ID = "https://best.dev/schema/crud/v1";
+var CRUD_SCHEMA_VERSION = 1;
+
+// src/lowcode/validate.ts
+var fieldComponents = /* @__PURE__ */ new Set([
+  "input",
+  "number",
+  "select",
+  "date",
+  "dateRange",
+  "textarea",
+  "slot",
+  "repeatable"
+]);
+var builtInEffects = /* @__PURE__ */ new Set([
+  "openCreate",
+  "openDetail",
+  "openEdit",
+  "remove",
+  "runAction",
+  "slot"
+]);
+var columnFormats = /* @__PURE__ */ new Set(["date", "datetime", "money", "text"]);
+function push(diagnostics, path, code, message2) {
+  diagnostics.push({ path, code, message: message2 });
+}
+function validateCondition(condition, path, diagnostics) {
+  if ((condition.operator === "and" || condition.operator === "or") && condition.conditions.length === 0) {
+    push(diagnostics, path, "condition.empty", "\u7EC4\u5408\u6761\u4EF6\u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B50\u6761\u4EF6");
+  }
+  if (condition.operator === "and" || condition.operator === "or") {
+    condition.conditions.forEach((item, index) => {
+      validateCondition(item, `${path}/conditions/${index}`, diagnostics);
+    });
+  }
+  if (condition.operator === "not")
+    validateCondition(condition.condition, `${path}/condition`, diagnostics);
+}
+function validateFields(fields, path, registry, diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  fields?.forEach((field, index) => {
+    const fieldPath = `${path}/${index}`;
+    if (!field.field) push(diagnostics, fieldPath, "field.missing", "\u5B57\u6BB5\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+    if (seen.has(field.field))
+      push(diagnostics, fieldPath, "field.duplicate", `\u5B57\u6BB5\u91CD\u590D\uFF1A${field.field}`);
+    seen.add(field.field);
+    if (!fieldComponents.has(field.component))
+      push(diagnostics, fieldPath, "field.component", `\u4E0D\u652F\u6301\u7684\u7EC4\u4EF6\uFF1A${field.component}`);
+    if (field.dict && registry && !registry.dictionaries[field.dict]) {
+      push(diagnostics, fieldPath, "registry.dictionary", `\u672A\u6CE8\u518C\u5B57\u5178\uFF1A${field.dict}`);
+    }
+    if (field.component === "slot" && !field.slot)
+      push(diagnostics, fieldPath, "field.slot", "slot \u7EC4\u4EF6\u5FC5\u987B\u6307\u5B9A slot key");
+    if (field.component === "repeatable" && !field.itemFields?.length)
+      push(
+        diagnostics,
+        fieldPath,
+        "field.repeatable",
+        "repeatable \u7EC4\u4EF6\u81F3\u5C11\u9700\u8981\u4E00\u4E2A itemFields \u5B57\u6BB5"
+      );
+    if (field.minItems !== void 0 && field.maxItems !== void 0 && field.minItems > field.maxItems)
+      push(diagnostics, fieldPath, "field.repeatable.range", "minItems \u4E0D\u80FD\u5927\u4E8E maxItems");
+    if (field.slot && registry && !registry.slots[field.slot])
+      push(diagnostics, fieldPath, "registry.slot", `\u672A\u6CE8\u518C\u63D2\u69FD\uFF1A${field.slot}`);
+    if (field.visibleWhen)
+      validateCondition(field.visibleWhen, `${fieldPath}/visibleWhen`, diagnostics);
+    if (field.disabledWhen)
+      validateCondition(field.disabledWhen, `${fieldPath}/disabledWhen`, diagnostics);
+  });
+}
+function validateActions(actions, path, registry, hasRemoveService, diagnostics) {
+  actions?.forEach((action, index) => {
+    const actionPath = `${path}/${index}`;
+    if (!action.id) push(diagnostics, actionPath, "action.missing", "\u52A8\u4F5C id \u4E0D\u80FD\u4E3A\u7A7A");
+    if (!builtInEffects.has(action.effect))
+      push(diagnostics, actionPath, "action.effect", `\u4E0D\u652F\u6301\u7684\u52A8\u4F5C\uFF1A${action.effect}`);
+    if (action.effect === "runAction" && !action.action)
+      push(diagnostics, actionPath, "action.key", "runAction \u5FC5\u987B\u6307\u5B9A action key");
+    if (action.effect === "remove" && !hasRemoveService)
+      push(diagnostics, actionPath, "action.removeService", "remove \u52A8\u4F5C\u5FC5\u987B\u914D\u7F6E dataSource.remove");
+    if (action.effect === "slot" && !action.slot)
+      push(diagnostics, actionPath, "action.slot", "slot \u52A8\u4F5C\u5FC5\u987B\u6307\u5B9A slot key");
+    if (action.action && registry && !registry.actions[action.action]) {
+      push(diagnostics, actionPath, "registry.action", `\u672A\u6CE8\u518C\u52A8\u4F5C\uFF1A${action.action}`);
+    }
+    if (action.slot && registry && !registry.slots[action.slot]) {
+      push(diagnostics, actionPath, "registry.slot", `\u672A\u6CE8\u518C\u63D2\u69FD\uFF1A${action.slot}`);
+    }
+  });
+}
+function validateCrudPageSchema(schema, registry) {
+  const diagnostics = [];
+  if (schema.$schema !== CRUD_SCHEMA_ID)
+    push(diagnostics, "/$schema", "schema.id", `\u4EC5\u652F\u6301 ${CRUD_SCHEMA_ID}`);
+  if (schema.version !== CRUD_SCHEMA_VERSION)
+    push(diagnostics, "/version", "schema.version", `\u4EC5\u652F\u6301\u7248\u672C ${CRUD_SCHEMA_VERSION}`);
+  if (!schema.id) push(diagnostics, "/id", "page.id", "\u9875\u9762 id \u4E0D\u80FD\u4E3A\u7A7A");
+  if (!schema.title) push(diagnostics, "/title", "page.title", "\u9875\u9762\u6807\u9898\u4E0D\u80FD\u4E3A\u7A7A");
+  if (!schema.dataSource?.list)
+    push(diagnostics, "/dataSource/list", "service.list", "\u5217\u8868\u670D\u52A1\u4E0D\u80FD\u4E3A\u7A7A");
+  if (schema.dataSource?.list && registry && !registry.listServices[schema.dataSource.list]) {
+    push(
+      diagnostics,
+      "/dataSource/list",
+      "registry.service",
+      `\u672A\u6CE8\u518C\u670D\u52A1\uFF1A${schema.dataSource.list}`
+    );
+  }
+  if (schema.dataSource?.detail && registry && !registry.services[schema.dataSource.detail]) {
+    push(
+      diagnostics,
+      "/dataSource/detail",
+      "registry.service",
+      `\u672A\u6CE8\u518C\u670D\u52A1\uFF1A${schema.dataSource.detail}`
+    );
+  }
+  if (schema.dataSource?.remove && registry && !registry.services[schema.dataSource.remove]) {
+    push(
+      diagnostics,
+      "/dataSource/remove",
+      "registry.service",
+      `\u672A\u6CE8\u518C\u670D\u52A1\uFF1A${schema.dataSource.remove}`
+    );
+  }
+  validateFields(schema.search, "/search", registry, diagnostics);
+  validateFields(schema.form, "/form", registry, diagnostics);
+  if (!schema.table?.rowKey) push(diagnostics, "/table/rowKey", "table.rowKey", "rowKey \u4E0D\u80FD\u4E3A\u7A7A");
+  if (!schema.table?.columns?.length)
+    push(diagnostics, "/table/columns", "table.columns", "\u81F3\u5C11\u9700\u8981\u4E00\u5217");
+  schema.table?.columns?.forEach((column, index) => {
+    if (column.format && !columnFormats.has(column.format)) {
+      push(
+        diagnostics,
+        `/table/columns/${index}/format`,
+        "column.format",
+        `\u4E0D\u652F\u6301\u7684\u683C\u5F0F\uFF1A${column.format}`
+      );
+    }
+    if (column.dict && registry && !registry.dictionaries[column.dict]) {
+      push(
+        diagnostics,
+        `/table/columns/${index}/dict`,
+        "registry.dictionary",
+        `\u672A\u6CE8\u518C\u5B57\u5178\uFF1A${column.dict}`
+      );
+    }
+    if (column.slot && registry && !registry.slots[column.slot]) {
+      push(
+        diagnostics,
+        `/table/columns/${index}/slot`,
+        "registry.slot",
+        `\u672A\u6CE8\u518C\u63D2\u69FD\uFF1A${column.slot}`
+      );
+    }
+  });
+  schema.detail?.fields.forEach((field, index) => {
+    if (field.slot && registry && !registry.slots[field.slot])
+      push(
+        diagnostics,
+        `/detail/fields/${index}/slot`,
+        "registry.slot",
+        `\u672A\u6CE8\u518C\u63D2\u69FD\uFF1A${field.slot}`
+      );
+  });
+  validateActions(
+    schema.table?.actions,
+    "/table/actions",
+    registry,
+    Boolean(schema.dataSource?.remove),
+    diagnostics
+  );
+  validateActions(
+    schema.toolbar,
+    "/toolbar",
+    registry,
+    Boolean(schema.dataSource?.remove),
+    diagnostics
+  );
+  return { valid: diagnostics.length === 0, diagnostics };
+}
+function assertValidCrudPageSchema(schema, registry) {
+  const result = validateCrudPageSchema(schema, registry);
+  if (!result.valid) {
+    const message2 = result.diagnostics.map((item) => `${item.path}: ${item.message}`).join("\n");
+    throw new Error(`Schema \u6821\u9A8C\u5931\u8D25\uFF1A
+${message2}`);
+  }
+}
+
+// src/lowcode/BestCrudPage.tsx
+import { Fragment as Fragment2, jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+function toFieldDefinition(field, options, slots) {
+  const slot = field.slot;
+  return {
+    field: field.field,
+    label: field.label,
+    component: field.component,
+    placeholder: field.placeholder,
+    options,
+    required: field.required,
+    disabled: field.disabled,
+    hidden: field.hidden,
+    maxDate: field.maxDate,
+    span: field.span,
+    visibleWhen: field.visibleWhen,
+    disabledWhen: field.disabledWhen,
+    clearWhenHidden: field.clearWhenHidden,
+    itemFields: field.itemFields?.map((item) => toFieldDefinition(item, [], slots)),
+    minItems: field.minItems,
+    maxItems: field.maxItems,
+    render: slot ? (context) => slots[slot]?.(context) : void 0,
+    rules: field.required ? [{ required: true, message: `\u8BF7\u586B\u5199${field.label}` }] : void 0
+  };
+}
+function useFields(fields = []) {
+  const registry = useBestRegistry();
+  return fields.map(
+    (field) => toFieldDefinition(
+      field,
+      field.dict ? registry.dictionaries[field.dict] ?? [] : [],
+      registry.slots
+    )
+  );
+}
+function toDetailField(field, dictionary, slots) {
+  const slot = field.slot;
+  const valueEnum = field.dict ? Object.fromEntries(
+    (dictionary[field.dict] ?? []).map((item) => [String(item.value), item.label])
+  ) : void 0;
+  return {
+    field: field.field,
+    label: field.label,
+    span: field.span,
+    valueEnum,
+    render: slot ? (value, record) => slots[slot]?.({ field: field.field, record, value }) ?? "-" : void 0
+  };
+}
+function toTableColumn(column, dictionary, slots) {
+  const valueEnum = column.dict ? Object.fromEntries(
+    (dictionary[column.dict] ?? []).map((item) => [String(item.value), { text: item.label }])
+  ) : void 0;
+  return {
+    dataIndex: column.field,
+    search: false,
+    title: column.title,
+    width: column.width,
+    valueEnum,
+    render: (value, record) => column.slot ? slots[column.slot]?.({ field: column.field, record, value }) ?? "-" : formatCrudValue(value, column.format)
+  };
+}
+function toProTableSearchColumn(field, dictionary) {
+  const valueType = (() => {
+    switch (field.component) {
+      case "number":
+        return "digit";
+      case "select":
+        return "select";
+      case "date":
+        return "date";
+      case "dateRange":
+        return "dateRange";
+      default:
+        return "text";
+    }
+  })();
+  const options = field.dict ? dictionary[field.dict] ?? [] : void 0;
+  return {
+    dataIndex: field.field,
+    title: field.label,
+    valueType,
+    search: true,
+    hideInTable: true,
+    initialValue: field.defaultValue,
+    fieldProps: {
+      ...options ? { options } : {},
+      ...field.maxDate === "today" ? { disabledDate: (current) => current.isAfter(dayjs3(), "day") } : {}
+    }
+  };
+}
+function confirmAction(content) {
+  return new Promise((resolve) => {
+    Modal2.confirm({
+      content,
+      okText: "\u786E\u8BA4",
+      cancelText: "\u53D6\u6D88",
+      onOk: () => resolve(true),
+      onCancel: () => resolve(false)
+    });
+  });
+}
+function BestCrudPage({ adapter, className, schema }) {
+  const registry = useBestRegistry();
+  assertValidCrudPageSchema(schema, registry);
+  const registeredListService = useBestListService(schema.dataSource.list);
+  if (!registeredListService) throw new Error(`\u672A\u6CE8\u518C\u5217\u8868\u670D\u52A1\uFF1A${schema.dataSource.list}`);
+  const listService = useCallback(
+    async (query2, options) => {
+      const response = await registeredListService(query2, options);
+      return adapter?.fromList ? { ...response, items: adapter.fromList(response.items) } : response;
+    },
+    [adapter, registeredListService]
+  );
+  const searchFields = useFields(schema.search);
+  const useBestSearch = schema.searchMode === "bestSearch";
+  const formFields = useFields(schema.form);
+  const actionRef = useRef(void 0);
+  const pageRequestRef = useRef(void 0);
+  const [query, setQuery] = useState2({});
+  const [drawer, setDrawer] = useState2({ mode: "closed" });
+  const [submitting, setSubmitting] = useState2(false);
+  const handleAction = useCallback(
+    async (action, record) => {
+      if (action.access && !registry.access(action.access)) return;
+      if (action.effect !== "remove" && !await confirmBeforeAction(action.confirm, confirmAction))
+        return;
+      if (action.effect === "openDetail") setDrawer({ mode: "detail", record });
+      if (action.effect === "openEdit") {
+        let editRecord = record;
+        if (schema.dataSource.detail) {
+          const detailService = registry.services[schema.dataSource.detail];
+          if (!detailService) {
+            message.error(`\u672A\u6CE8\u518C\u670D\u52A1\uFF1A${schema.dataSource.detail}`);
+            return;
+          }
+          try {
+            const detail = await detailService(record ?? {});
+            if (detail && typeof detail === "object" && !Array.isArray(detail)) {
+              editRecord = adapter?.fromDetail ? adapter.fromDetail(detail) : detail;
+            }
+          } catch (error) {
+            message.error(errorMessage(error, `${schema.title}\u8BE6\u60C5\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`));
+            return;
+          }
+        }
+        setDrawer({ mode: "edit", record: editRecord });
+      }
+      if (action.effect === "openCreate") setDrawer({ mode: "create" });
+      if (action.effect === "remove" && schema.dataSource.remove) {
+        const removeService = registry.services[schema.dataSource.remove];
+        if (!removeService) return;
+        try {
+          const deleted = await removeCrudRecord(
+            record ?? {},
+            removeService,
+            action.confirm ?? `\u786E\u8BA4\u5220\u9664${schema.title}\uFF1F`,
+            confirmAction
+          );
+          if (deleted) {
+            message.success("\u5220\u9664\u6210\u529F");
+            actionRef.current?.reload();
+          }
+        } catch (error) {
+          message.error(errorMessage(error, "\u5220\u9664\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"));
+        }
+      }
+      if (action.effect === "runAction" && action.action) {
+        try {
+          await registry.actions[action.action]?.({ record });
+          actionRef.current?.reload();
+        } catch (error) {
+          message.error(errorMessage(error, `${action.label}\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`));
+        }
+      }
+    },
+    [registry]
+  );
+  const columns = useMemo3(() => {
+    const proTableSearchFields = useBestSearch ? [] : schema.search ?? [];
+    const searchColumns = new Map(
+      proTableSearchFields.map((field) => [
+        field.field,
+        toProTableSearchColumn(field, registry.dictionaries)
+      ])
+    );
+    const configuredColumns = schema.table.columns.map((column) => {
+      const tableColumn = toTableColumn(column, registry.dictionaries, registry.slots);
+      const searchColumn = searchColumns.get(column.field);
+      if (!searchColumn) return tableColumn;
+      searchColumns.delete(column.field);
+      return { ...tableColumn, ...searchColumn, hideInTable: false };
+    });
+    configuredColumns.push(...searchColumns.values());
+    if (!schema.table.actions?.length) return configuredColumns;
+    configuredColumns.push({
+      title: "\u64CD\u4F5C",
+      valueType: "option",
+      render: (_, record) => schema.table.actions?.map((action) => /* @__PURE__ */ jsx11(ActionButton, { action, record, onExecute: handleAction }, action.id))
+    });
+    return configuredColumns;
+  }, [
+    handleAction,
+    registry.dictionaries,
+    registry.slots,
+    schema.search,
+    schema.table.actions,
+    schema.table.columns,
+    useBestSearch
+  ]);
+  const request = useMemo3(() => {
+    pageRequestRef.current?.abort();
+    const pageRequest = createLatestPageRequest(
+      listService,
+      (error) => message.error(errorMessage(error, `${schema.title}\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5`))
+    );
+    pageRequestRef.current = pageRequest;
+    return (params, sort) => pageRequest.request(toBestListQuery({ ...params, ...query }, sort));
+  }, [listService, query, schema.title]);
+  useEffect3(() => () => pageRequestRef.current?.abort(), []);
+  const rowKey = schema.table.rowKey;
+  const submitForm = useCallback(
+    async (values) => {
+      const serviceKey = drawer.mode === "edit" ? schema.dataSource.update : schema.dataSource.create;
+      if (!serviceKey) return;
+      const record = drawer.mode === "closed" ? void 0 : drawer.record;
+      setSubmitting(true);
+      try {
+        const mergedValues = { ...record, ...values };
+        const payload = drawer.mode === "edit" ? adapter?.toUpdatePayload?.(mergedValues, record) ?? mergedValues : adapter?.toCreatePayload?.(mergedValues) ?? mergedValues;
+        await registry.services[serviceKey]?.(payload);
+        message.success("\u4FDD\u5B58\u6210\u529F");
+        setDrawer({ mode: "closed" });
+        actionRef.current?.reload();
+      } catch (error) {
+        message.error(errorMessage(error, "\u4FDD\u5B58\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"));
+      } finally {
+        setSubmitting(false);
+      }
+    },
+    [adapter, drawer, registry.services, schema.dataSource.create, schema.dataSource.update]
+  );
+  return /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    useBestSearch && searchFields.length ? /* @__PURE__ */ jsx11(
+      BestSearch,
+      {
+        fields: searchFields,
+        onReset: () => {
+          setQuery({});
+          actionRef.current?.reload();
+        },
+        onSearch: (values) => {
+          setQuery(values);
+          actionRef.current?.reload();
+        }
+      }
+    ) : null,
+    /* @__PURE__ */ jsx11(
+      BestTable,
+      {
+        actionRef,
+        className,
+        columns,
+        pagination: { showSizeChanger: true, defaultPageSize: schema.table.pageSize ?? 20 },
+        request,
+        rowKey: Array.isArray(rowKey) ? (record) => rowKey.map((field) => String(record[field] ?? "")).join("-") : rowKey,
+        search: useBestSearch ? false : void 0,
+        scroll: schema.table.scrollX ? { x: schema.table.scrollX } : void 0,
+        toolBarRender: () => schema.toolbar?.map((action) => /* @__PURE__ */ jsx11(ActionButton, { action, onExecute: handleAction }, action.id)) ?? []
+      }
+    ),
+    /* @__PURE__ */ jsxs4(
+      BestDrawer,
+      {
+        open: drawer.mode !== "closed",
+        title: drawer.mode === "detail" ? `${schema.title}\u8BE6\u60C5` : drawer.mode === "edit" ? `\u7F16\u8F91${schema.title}` : `\u65B0\u5EFA${schema.title}`,
+        onClose: () => setDrawer({ mode: "closed" }),
+        children: [
+          drawer.mode === "detail" ? /* @__PURE__ */ jsx11(
+            BestDetail,
+            {
+              fields: schema.detail?.fields.map(
+                (field) => toDetailField(field, registry.dictionaries, registry.slots)
+              ) ?? [],
+              record: drawer.record
+            }
+          ) : null,
+          drawer.mode === "edit" || drawer.mode === "create" ? /* @__PURE__ */ jsx11(
+            BestForm,
+            {
+              fields: formFields,
+              initialValues: drawer.record,
+              loading: submitting,
+              mode: drawer.mode,
+              onCancel: () => setDrawer({ mode: "closed" }),
+              onSubmit: (values) => {
+                void submitForm(values);
+              }
+            }
+          ) : null
+        ]
+      }
+    )
+  ] });
+  function ActionButton({
+    action,
+    record,
+    onExecute
+  }) {
+    const permitted = !action.access || registry.access(action.access);
+    if (!permitted) return null;
+    if (action.effect === "slot" && action.slot) {
+      return registry.slots[action.slot]?.({ record }) ?? null;
+    }
+    return /* @__PURE__ */ jsx11(
+      Button4,
+      {
+        type: "link",
+        onClick: () => {
+          void onExecute(action, record);
+        },
+        children: action.label
+      },
+      action.id
+    );
+  }
+}
+export {
+  BestBatchInput,
+  BestCrudPage,
+  BestDetail,
+  BestDrawer,
+  BestEmpty,
+  BestError,
+  BestFilePreview,
+  BestForm,
+  BestLightTable,
+  BestLoading,
+  BestModal,
+  BestProvider,
+  BestSearch,
+  BestTable,
+  CRUD_SCHEMA_ID,
+  CRUD_SCHEMA_VERSION,
+  assertValidCrudPageSchema,
+  createBestRegistry,
+  useBestAccess,
+  useBestAction,
+  useBestDictionary,
+  useBestListService,
+  useBestRegistry,
+  useBestService,
+  validateCrudPageSchema
+};
+//# sourceMappingURL=index.js.map