@mijalowcode/materials 1.0.9 → 1.1.0

package/dist/chunk-SHABHYWT.js

@@ -0,0 +1,585 @@
+import dayjs from 'dayjs';
+import { List } from 'antd';
+import { createElement } from 'react';
+
+// src/runtime-adapters/columns-request.ts
+function getValueByPath(source, path) {
+  const finalPath = String(path).trim();
+  if (!finalPath) return void 0;
+  return finalPath.split(".").reduce((acc, segment) => {
+    if (!segment) return acc;
+    if (acc && typeof acc === "object") {
+      return acc[segment];
+    }
+    return void 0;
+  }, source);
+}
+function normalizeSelectOptionsFromResult(result) {
+  const source = getValueByPath(result, "data");
+  const list = Array.isArray(source) ? source : Array.isArray(result) ? result : [];
+  return list.reduce(
+    (acc, item) => {
+      const record = item && typeof item === "object" ? item : {};
+      const value = record.value ?? record.id ?? record.code;
+      if (value === void 0 || value === null) return acc;
+      const text = record.label ?? record.name ?? record.text ?? value;
+      acc.push({
+        label: String(text),
+        value
+      });
+      return acc;
+    },
+    []
+  );
+}
+function resolveColumnRequestEvent(column) {
+  const direct = String(column._requestEvent || "").trim();
+  if (direct) return direct;
+  return "";
+}
+function buildColumnRequestPayload(requestEvent, params, column) {
+  const requestParams = params && typeof params === "object" && !Array.isArray(params) ? params : {};
+  const field = String(column.dataIndex || column.key || "").trim();
+  return {
+    ...requestParams,
+    requestEvent,
+    params: requestParams,
+    field,
+    column
+  };
+}
+function resolveDateRangePresetInitialValue(preset) {
+  const now = dayjs();
+  switch (preset) {
+    case "currentMonth":
+      return [now.startOf("month"), now.endOf("month")];
+    case "lastMonth": {
+      const base = now.subtract(1, "month");
+      return [base.startOf("month"), base.endOf("month")];
+    }
+    case "last7Days":
+      return [now.subtract(6, "day").startOf("day"), now.endOf("day")];
+    case "last30Days":
+      return [now.subtract(1, "month").startOf("day"), now.endOf("day")];
+    case "currentWeek":
+      return [now.startOf("week"), now.endOf("week")];
+    default:
+      return void 0;
+  }
+}
+function normalizeColumnFormItemProps(column) {
+  const valueType = String(column.valueType || "");
+  if (!["dateRange", "dateTimeRange"].includes(valueType)) {
+    return column.formItemProps;
+  }
+  const raw = column.formItemProps && typeof column.formItemProps === "object" && !Array.isArray(column.formItemProps) ? column.formItemProps : void 0;
+  if (!raw) return column.formItemProps;
+  if (String(raw.initialValueMode || "") !== "preset") return raw;
+  const preset = String(raw.initialValuePreset || "");
+  if (!preset) return raw;
+  const rangeValue = resolveDateRangePresetInitialValue(preset);
+  if (!rangeValue) return raw;
+  return {
+    ...raw,
+    initialValue: rangeValue
+  };
+}
+function attachColumnsRequestByEvent(columns, runRequestEvent) {
+  if (!Array.isArray(columns)) return columns;
+  return columns.map((column) => {
+    if (!column || typeof column !== "object") return column;
+    const current = column;
+    const normalizedFormItemProps = normalizeColumnFormItemProps(current);
+    const normalizedColumn = normalizedFormItemProps === current.formItemProps ? current : {
+      ...current,
+      formItemProps: normalizedFormItemProps
+    };
+    const requestEvent = resolveColumnRequestEvent(current);
+    if (!requestEvent) return normalizedColumn;
+    return {
+      ...normalizedColumn,
+      request: async (params) => {
+        const payload = buildColumnRequestPayload(
+          requestEvent,
+          params,
+          current
+        );
+        const result = await runRequestEvent(requestEvent, payload);
+        return normalizeSelectOptionsFromResult(result);
+      }
+    };
+  });
+}
+var columnsRequestAdapter = {
+  adaptProps: (props, context) => {
+    if (!("columns" in props)) return props;
+    return {
+      ...props,
+      columns: attachColumnsRequestByEvent(props.columns, context.runRequestEvent)
+    };
+  }
+};
+function normalizeListDataSource(dataSource) {
+  return Array.isArray(dataSource) ? dataSource : [];
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeGridNumber(value) {
+  if (typeof value !== "number") return void 0;
+  if (!Number.isFinite(value)) return void 0;
+  return value;
+}
+function normalizeListGrid(grid) {
+  if (!isPlainObject(grid)) return void 0;
+  const nextGrid = Object.entries(grid).reduce(
+    (acc, [key, value]) => {
+      const nextValue = normalizeGridNumber(value);
+      if (nextValue !== void 0) {
+        acc[key] = nextValue;
+      }
+      return acc;
+    },
+    {}
+  );
+  return Object.keys(nextGrid).length > 0 ? nextGrid : void 0;
+}
+function getListItemKey(record, index, rowKey) {
+  const keyField = String(rowKey || "").trim();
+  if (keyField && record && typeof record === "object" && !Array.isArray(record)) {
+    const value = record[keyField];
+    if (value !== void 0 && value !== null && value !== "") {
+      return String(value);
+    }
+  }
+  return String(index);
+}
+function buildListItemRuntimeContext(runtimeContext, record, index, rowKey, list) {
+  const baseData = runtimeContext?.data && typeof runtimeContext.data === "object" && !Array.isArray(runtimeContext.data) ? runtimeContext.data : {};
+  return {
+    ...runtimeContext || {},
+    data: {
+      ...baseData,
+      record,
+      item: record,
+      index,
+      rowKey,
+      list
+    }
+  };
+}
+var listTemplateAdapter = {
+  adaptProps: (props, context) => {
+    const {
+      children: _children,
+      rowKey,
+      previewCount,
+      grid,
+      ...restProps
+    } = props;
+    const safeGrid = normalizeListGrid(grid);
+    const normalizedProps = safeGrid ? { ...restProps, grid: safeGrid } : restProps;
+    if (!context.hasChildren || !context.renderChildren) {
+      return normalizedProps;
+    }
+    const rows = normalizeListDataSource(props.dataSource);
+    const rowKeyField = String(rowKey || "").trim();
+    return {
+      ...normalizedProps,
+      dataSource: rows,
+      renderItem: (record, rowIndex) => {
+        const itemKey = getListItemKey(record, rowIndex, rowKeyField);
+        const nextRuntimeContext = buildListItemRuntimeContext(
+          context.runtimeContext,
+          record,
+          rowIndex,
+          itemKey,
+          rows
+        );
+        return createElement(
+          List.Item,
+          { key: itemKey },
+          context.renderChildren?.(nextRuntimeContext)
+        );
+      }
+    };
+  }
+};
+
+// src/runtime-adapters/index.ts
+var columnsAdapterComponentNames = /* @__PURE__ */ new Set([
+  "ProTable",
+  "SchemaForm",
+  "Table"
+]);
+var defaultComponentAdapterRegistry = {
+  get: (componentName) => {
+    if (componentName === "List") {
+      return listTemplateAdapter;
+    }
+    if (columnsAdapterComponentNames.has(componentName)) {
+      return columnsRequestAdapter;
+    }
+    return null;
+  }
+};
+
+// src/material-manifest.ts
+var defaultMaterialLoadOptions = {
+  includeMeta: false
+};
+function shouldLoadMeta(options) {
+  return Boolean(options?.includeMeta);
+}
+function pick(source, path) {
+  return path.split(".").reduce((acc, segment) => {
+    if (!acc || typeof acc !== "object") return void 0;
+    return acc[segment];
+  }, source);
+}
+async function loadWeb(exportPath, metaLoader, options = defaultMaterialLoadOptions) {
+  const [web, meta] = await Promise.all([
+    import('@mijadesign/web'),
+    shouldLoadMeta(options) ? metaLoader?.() : void 0
+  ]);
+  return { component: pick(web, exportPath), meta };
+}
+async function loadAntdLayout(exportPath, metaLoader, options = defaultMaterialLoadOptions) {
+  const [antd, meta] = await Promise.all([
+    import('antd'),
+    shouldLoadMeta(options) ? metaLoader?.() : void 0
+  ]);
+  return { component: pick(antd, exportPath), meta };
+}
+async function loadDefault(componentLoader, metaLoader, adapter, options = defaultMaterialLoadOptions) {
+  const [componentModule, meta] = await Promise.all([
+    componentLoader(),
+    shouldLoadMeta(options) ? metaLoader?.() : void 0
+  ]);
+  return { component: componentModule.default, adapter, meta };
+}
+var loadColumnsAdapter = () => columnsRequestAdapter;
+var manifestLoadCache = /* @__PURE__ */ new WeakMap();
+function getManifestCache(manifest) {
+  const existing = manifestLoadCache.get(manifest);
+  if (existing) return existing;
+  const next = /* @__PURE__ */ new Map();
+  manifestLoadCache.set(manifest, next);
+  return next;
+}
+function loadCachedMaterial(componentName, entry, manifest, options) {
+  const cache = getManifestCache(manifest);
+  const cacheKey = `${componentName}:${shouldLoadMeta(options) ? "meta" : "runtime"}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+  const loading = entry(options).catch((error) => {
+    cache.delete(cacheKey);
+    throw error;
+  });
+  cache.set(cacheKey, loading);
+  return loading;
+}
+function clearMaterialLoadCache(manifest) {
+  if (manifest) {
+    manifestLoadCache.delete(manifest);
+    return;
+  }
+  manifestLoadCache.delete(materialManifest);
+}
+var materialManifest = {
+  Button: () => loadDefault(
+    () => import('./ButtonWrapper-HJIWAEIJ.js'),
+    async () => (await import('./meta-DJOKJFNL.js')).ButtonMeta
+  ),
+  Space: () => loadDefault(
+    () => import('./SpaceWrapper-64YCSAFK.js'),
+    async () => (await import('./meta-FGF6WHFT.js')).SpaceMeta
+  ),
+  DesensitizationDisplay: () => loadDefault(
+    () => import('./DesensitizationDisplay-XWRRKQ66.js'),
+    async () => (await import('./meta-JJU3VEWF.js')).DesensitizationDisplayMeta
+  ),
+  Layout: () => loadAntdLayout(
+    "Layout",
+    async () => (await import('./meta-6MBV5UX6.js')).LayoutMeta
+  ),
+  "Layout.Header": () => loadAntdLayout("Layout.Header"),
+  "Layout.Sider": () => loadAntdLayout("Layout.Sider"),
+  "Layout.Content": () => loadAntdLayout("Layout.Content"),
+  "Layout.Footer": () => loadAntdLayout("Layout.Footer"),
+  Header: () => loadAntdLayout(
+    "Layout.Header",
+    async () => (await import('./meta-6MBV5UX6.js')).HeaderMeta
+  ),
+  Sider: () => loadAntdLayout(
+    "Layout.Sider",
+    async () => (await import('./meta-6MBV5UX6.js')).SiderMeta
+  ),
+  Content: () => loadAntdLayout(
+    "Layout.Content",
+    async () => (await import('./meta-6MBV5UX6.js')).ContentMeta
+  ),
+  Footer: () => loadAntdLayout(
+    "Layout.Footer",
+    async () => (await import('./meta-6MBV5UX6.js')).FooterMeta
+  ),
+  Row: () => loadWeb("Row", async () => (await import('./meta-6MBV5UX6.js')).RowMeta),
+  Col: () => loadWeb("Col", async () => (await import('./meta-6MBV5UX6.js')).ColMeta),
+  Card: () => loadWeb("Card", async () => (await import('./meta-3MAHIMCP.js')).CardMeta),
+  Input: () => loadWeb("Input", async () => (await import('./meta-DERU26SP.js')).InputMeta),
+  "Input.TextArea": () => loadWeb(
+    "Input.TextArea",
+    async () => (await import('./meta-DERU26SP.js')).InputTextAreaMeta
+  ),
+  "Input.Search": () => loadWeb("Input.Search"),
+  "Input.Password": () => loadWeb("Input.Password"),
+  Form: () => loadWeb("Form", async () => (await import('./meta-TOI7GX4E.js')).FormMeta),
+  "Form.Item": () => loadWeb(
+    "Form.Item",
+    async () => (await import('./meta-TOI7GX4E.js')).FormItemMeta
+  ),
+  "Form.List": () => loadWeb(
+    "Form.List",
+    async () => (await import('./meta-TOI7GX4E.js')).FormListMeta
+  ),
+  Select: () => loadWeb(
+    "Select",
+    async () => (await import('./meta-TBKMGQSZ.js')).SelectMeta
+  ),
+  InputNumber: () => loadWeb(
+    "InputNumber",
+    async () => (await import('./meta-HICX3KO3.js')).InputNumberMeta
+  ),
+  DatePicker: () => loadWeb(
+    "DatePicker",
+    async () => (await import('./meta-42VAOQFA.js')).DatePickerMeta
+  ),
+  "DatePicker.RangePicker": () => loadWeb(
+    "DatePicker.RangePicker",
+    async () => (await import('./meta-42VAOQFA.js')).RangePickerMeta
+  ),
+  TimePicker: () => loadWeb(
+    "TimePicker",
+    async () => (await import('./meta-42VAOQFA.js')).TimePickerMeta
+  ),
+  Upload: () => loadWeb(
+    "Upload",
+    async () => (await import('./meta-GR253RQD.js')).UploadMeta
+  ),
+  Tree: () => loadWeb("Tree", async () => (await import('./meta-LNTBRX26.js')).TreeMeta),
+  TreeSelect: () => loadWeb(
+    "TreeSelect",
+    async () => (await import('./meta-LNTBRX26.js')).TreeSelectMeta
+  ),
+  Tabs: () => loadWeb("Tabs", async () => (await import('./meta-7WHM3VRP.js')).TabsMeta),
+  "Tabs.TabPane": () => loadWeb(
+    "Tabs.TabPane",
+    async () => (await import('./meta-7WHM3VRP.js')).TabPaneMeta
+  ),
+  Steps: () => loadWeb("Steps", async () => (await import('./meta-55RZ5PXQ.js')).StepsMeta),
+  "Steps.Step": () => loadWeb(
+    "Steps.Step",
+    async () => (await import('./meta-55RZ5PXQ.js')).StepMeta
+  ),
+  Tag: () => loadDefault(
+    () => import('./TagWrapper-AD7PU5ZM.js'),
+    async () => (await import('./meta-3VCBT7DM.js')).TagMeta
+  ),
+  "Tag.CheckableTag": () => loadWeb(
+    "Tag.CheckableTag",
+    async () => (await import('./meta-3VCBT7DM.js')).CheckableTagMeta
+  ),
+  ScenarioFlowBoard: () => loadDefault(
+    () => import('./ScenarioFlowBoard-5OSRKNQ6.js'),
+    async () => (await import('./meta-TJ6XD3EH.js')).ScenarioFlowBoardMeta
+  ),
+  ScenarioFlowScene: () => loadDefault(
+    () => import('./ScenarioFlowScene-JMFMGXMW.js'),
+    async () => (await import('./meta-2DGW4AUA.js')).ScenarioFlowSceneMeta
+  ),
+  ScenarioFlowStep: () => loadDefault(
+    () => import('./ScenarioFlowStep-UBDHMM3R.js'),
+    async () => (await import('./meta-QQUKGT3S.js')).ScenarioFlowStepMeta
+  ),
+  Badge: () => loadWeb("Badge", async () => (await import('./meta-FXUDXBCE.js')).BadgeMeta),
+  "Badge.Ribbon": () => loadWeb(
+    "Badge.Ribbon",
+    async () => (await import('./meta-FXUDXBCE.js')).BadgeRibbonMeta
+  ),
+  Avatar: () => loadWeb(
+    "Avatar",
+    async () => (await import('./meta-Q576PPQP.js')).AvatarMeta
+  ),
+  "Avatar.Group": () => loadWeb(
+    "Avatar.Group",
+    async () => (await import('./meta-Q576PPQP.js')).AvatarGroupMeta
+  ),
+  Dropdown: () => loadWeb(
+    "Dropdown",
+    async () => (await import('./meta-A5U2QQIN.js')).DropdownMeta
+  ),
+  "Dropdown.Button": () => loadWeb(
+    "Dropdown.Button",
+    async () => (await import('./meta-A5U2QQIN.js')).DropdownButtonMeta
+  ),
+  Pagination: () => loadWeb(
+    "Pagination",
+    async () => (await import('./meta-UOPC3XRK.js')).PaginationMeta
+  ),
+  Switch: () => loadWeb(
+    "Switch",
+    async () => (await import('./meta-WRUN4G5H.js')).SwitchMeta
+  ),
+  Radio: () => loadWeb("Radio", async () => (await import('./meta-KECACK5B.js')).RadioMeta),
+  "Radio.Group": () => loadWeb(
+    "Radio.Group",
+    async () => (await import('./meta-KECACK5B.js')).RadioGroupMeta
+  ),
+  RadioButton: () => loadWeb("Radio.Button"),
+  Checkbox: () => loadWeb(
+    "Checkbox",
+    async () => (await import('./meta-JXV3FTYT.js')).CheckboxMeta
+  ),
+  "Checkbox.Group": () => loadWeb(
+    "Checkbox.Group",
+    async () => (await import('./meta-JXV3FTYT.js')).CheckboxGroupMeta
+  ),
+  Cascader: () => loadWeb(
+    "Cascader",
+    async () => (await import('./meta-RP5DBUF7.js')).CascaderMeta
+  ),
+  Table: () => loadWeb(
+    "Table",
+    async () => (await import('./meta-RNDJB4QM.js')).TableMeta
+  ).then((module) => ({ ...module, adapter: loadColumnsAdapter() })),
+  Typography: () => loadWeb("Typography"),
+  "Typography.Title": () => loadWeb(
+    "Typography.Title",
+    async () => (await import('./meta-HT2THPPL.js')).TypographyTitleMeta
+  ),
+  "Typography.Paragraph": () => loadWeb(
+    "Typography.Paragraph",
+    async () => (await import('./meta-HT2THPPL.js')).TypographyParagraphMeta
+  ),
+  "Typography.Text": () => loadWeb(
+    "Typography.Text",
+    async () => (await import('./meta-HT2THPPL.js')).TypographyTextMeta
+  ),
+  ProTable: () => loadDefault(
+    () => import('./ProTableWrapper-2VRYHYZG.js'),
+    async () => (await import('./meta-H4O7NLPL.js')).ProTableMeta,
+    loadColumnsAdapter()
+  ),
+  SchemaForm: () => loadDefault(
+    () => import('./SchemaFormWrapper-2BMRJNZR.js'),
+    async () => (await import('./meta-QJUDUO5X.js')).SchemaFormMeta,
+    loadColumnsAdapter()
+  ),
+  FilterColumns: () => loadDefault(
+    () => import('./FilterColumnsWrapper-A5HEX3JS.js'),
+    async () => (await import('./meta-S3AC3URV.js')).FilterColumnsMeta
+  ),
+  Modal: () => loadWeb("Modal", async () => (await import('./meta-QRIJQJP6.js')).ModalMeta),
+  Drawer: () => loadDefault(
+    () => import('./DrawerWrapper-S4DWP4YO.js'),
+    async () => (await import('./meta-QLQ44DMU.js')).DrawerMeta
+  ),
+  Descriptions: () => loadWeb(
+    "Descriptions",
+    async () => (await import('./meta-WC52ATG7.js')).DescriptionsMeta
+  ),
+  "Descriptions.Item": () => loadWeb("Descriptions.Item"),
+  List: () => loadWeb("List", async () => (await import('./meta-2OQC4QK3.js')).ListMeta).then((module) => ({ ...module, adapter: listTemplateAdapter })),
+  "List.Item": () => loadWeb(
+    "List.Item",
+    async () => (await import('./meta-2OQC4QK3.js')).ListItemMeta
+  ),
+  Empty: () => loadDefault(
+    () => import('./EmptyWrapper-ASEWZWLM.js'),
+    async () => (await import('./meta-DTZJTPJN.js')).EmptyMeta
+  ),
+  Spin: () => loadWeb("Spin", async () => (await import('./meta-MSI74GOD.js')).SpinMeta),
+  Alert: () => loadWeb("Alert", async () => (await import('./meta-RLZ76RVJ.js')).AlertMeta),
+  Progress: () => loadWeb(
+    "Progress",
+    async () => (await import('./meta-AS6FTLIL.js')).ProgressMeta
+  ),
+  Skeleton: () => loadWeb(
+    "Skeleton",
+    async () => (await import('./meta-BI6QS2UV.js')).SkeletonMeta
+  ),
+  Tooltip: () => loadWeb(
+    "Tooltip",
+    async () => (await import('./meta-BI6QS2UV.js')).TooltipMeta
+  ),
+  Popconfirm: () => loadWeb(
+    "Popconfirm",
+    async () => (await import('./meta-BI6QS2UV.js')).PopconfirmMeta
+  ),
+  Popover: () => loadDefault(
+    () => import('./PopoverWrapper-STPU5XIE.js'),
+    async () => (await import('./meta-K5WYLIMW.js')).PopoverMeta
+  ),
+  Divider: () => loadWeb(
+    "Divider",
+    async () => (await import('./meta-7PJVW2JY.js')).DividerMeta
+  ),
+  Statistic: () => loadWeb(
+    "Statistic",
+    async () => (await import('./meta-ODFHN4VH.js')).StatisticMeta
+  ),
+  Timeline: () => loadWeb(
+    "Timeline",
+    async () => (await import('./meta-WUAJDZOE.js')).TimelineMeta
+  ),
+  "Timeline.Item": () => loadWeb(
+    "Timeline.Item",
+    async () => (await import('./meta-WUAJDZOE.js')).TimelineItemMeta
+  ),
+  Result: () => loadWeb("Result", async () => (await import('./meta-DQUW4T7A.js')).ResultMeta)
+};
+async function loadMaterialModules(componentNames, manifest = materialManifest, options = defaultMaterialLoadOptions) {
+  const components = {};
+  const adapters = {};
+  const metas = {};
+  const missing = [];
+  const names = Array.from(new Set(Array.from(componentNames).filter(Boolean)));
+  const pending = [...names];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const componentName = pending.shift();
+    if (!componentName || visited.has(componentName)) continue;
+    visited.add(componentName);
+    const entry = manifest[componentName];
+    if (!entry) {
+      missing.push(componentName);
+      continue;
+    }
+  }
+  await Promise.all(
+    Array.from(visited).map(async (componentName) => {
+      const loader = manifest[componentName];
+      if (!loader) {
+        return;
+      }
+      const module = await loadCachedMaterial(
+        componentName,
+        loader,
+        manifest,
+        options
+      );
+      if (!module.component) {
+        missing.push(componentName);
+        return;
+      }
+      components[componentName] = module.component;
+      if (module.adapter) adapters[componentName] = module.adapter;
+      if (module.meta) metas[componentName] = module.meta;
+    })
+  );
+  return { components, adapters, metas, missing };
+}
+
+export { clearMaterialLoadCache, columnsRequestAdapter, defaultComponentAdapterRegistry, listTemplateAdapter, loadMaterialModules, materialManifest };
+//# sourceMappingURL=chunk-SHABHYWT.js.map
+//# sourceMappingURL=chunk-SHABHYWT.js.map