@nocobase/client-v2 2.1.0-alpha.4 → 2.1.0-alpha.45

package/src/components/form/table/styles.ts

@@ -0,0 +1,129 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { css } from '@emotion/css';
+import { SORT_HANDLE_GUTTER } from './constants';
+
+/**
+ * Restore horizontal scrolling on `.ant-table-content` so wide tables in
+ * narrow containers (drawer / settings panel) scroll their inner `<table>`
+ * instead of getting clipped or forcing the outer container to grow.
+ *
+ * `width: max-content` on the inner `<table>` lets columns size to their
+ * natural width; `min-width: 100%` keeps the table filling the viewport
+ * when total column width is smaller than the container.
+ */
+export const tableScrollClassName = css`
+  &.ant-table-wrapper .ant-table-content {
+    overflow: auto hidden;
+  }
+  &.ant-table-wrapper .ant-table-content > table {
+    width: max-content;
+    min-width: 100%;
+  }
+`;
+
+/**
+ * Reserve a `SORT_HANDLE_GUTTER`-wide gap on the left of the rowSelection
+ * column so the handle's `left:0` lands inside a `position:relative` cell.
+ * Padding is mirrored on both the header `<th>` and body `<td>` so the
+ * "select all" checkbox stays vertically aligned with body checkboxes.
+ *
+ * The class is a module-level constant — emotion's hash is stable across
+ * re-renders, so the caller doesn't need a `useMemo` to keep referential
+ * equality.
+ */
+export const selectionGutterClassName = css`
+  .ant-table-thead > tr > th.ant-table-selection-column,
+  .ant-table-tbody > tr > td.ant-table-selection-column {
+    padding-left: ${SORT_HANDLE_GUTTER}px !important;
+    position: relative;
+  }
+`;
+
+/**
+ * Index ↔ checkbox hover swap CSS. Both `.nb-table-index` and the antd
+ * checkbox (wrapped in `.nb-origin-node`) are absolutely positioned and
+ * centered inside `.nb-row-selection-cell`, so they share the same anchor
+ * without one displacing the other. `display: none/flex` flips so they never
+ * overlap mid-transition.
+ */
+export const indexSwapClassName = css`
+  .ant-table-tbody > tr > td.ant-table-selection-column {
+    .nb-row-selection-cell {
+      position: relative;
+      display: inline-block;
+      min-width: 22px;
+      min-height: 22px;
+      vertical-align: middle;
+    }
+    .nb-row-selection-cell .nb-table-index,
+    .nb-row-selection-cell .nb-origin-node {
+      position: absolute;
+      inset: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .nb-row-selection-cell .nb-origin-node {
+      display: none;
+    }
+    .nb-row-selection-cell.checked .nb-table-index {
+      display: none;
+    }
+    .nb-row-selection-cell.checked .nb-origin-node {
+      display: flex;
+    }
+  }
+  .ant-table-tbody > tr:hover > td.ant-table-selection-column {
+    .nb-row-selection-cell .nb-table-index {
+      display: none;
+    }
+    .nb-row-selection-cell .nb-origin-node {
+      display: flex;
+    }
+  }
+`;
+
+/**
+ * Self-contained styles for the drag-overlay clone. The runtime
+ * `selectionGutterClassName` + `indexSwapClassName` are scoped to AntdTable's
+ * emotion hash, so they don't reach the cloned `<tr>` injected via
+ * `dangerouslySetInnerHTML`. This class replays the minimal subset that the
+ * clone needs:
+ *   - selection column gutter + `position: relative` so the absolute handle
+ *     lands correctly
+ *   - hide the row index inside the overlay (drag preview shouldn't carry
+ *     a stale ordinal)
+ *   - force the checkbox (`.nb-origin-node`) absolute-centered and visible
+ *     regardless of hover/checked state, so the selection cell isn't empty
+ */
+export const overlayCellStylesClassName = css`
+  .ant-table-cell.ant-table-selection-column {
+    padding-left: ${SORT_HANDLE_GUTTER}px !important;
+    position: relative;
+  }
+  .nb-table-index {
+    display: none !important;
+  }
+  .nb-row-selection-cell {
+    position: relative;
+    display: inline-block;
+    min-width: 22px;
+    min-height: 22px;
+    vertical-align: middle;
+  }
+  .nb-row-selection-cell .nb-origin-node {
+    position: absolute;
+    inset: 0;
+    display: flex !important;
+    align-items: center;
+    justify-content: center;
+  }
+`;

package/src/components/form/table/utils.ts

@@ -0,0 +1,75 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type React from 'react';
+
+/**
+ * Same shape as antd Table's `rowKey` prop — either a record key name or a
+ * function. Hoisted here so utilities and `Table.tsx` agree on the contract.
+ */
+export type RowKey<RecordType extends object> =
+  | (keyof RecordType & (string | number))
+  | ((record: RecordType, index?: number) => React.Key);
+
+/**
+ * Read a stable row id off a record. Mirrors antd Table's rowKey resolution
+ * but normalises non-primitive ids to strings so `data-row-key` attributes
+ * and `useSortable({ id })` agree on equality.
+ */
+export function readRowKey<RecordType extends object>(
+  record: RecordType,
+  rowKey: RowKey<RecordType>,
+  index?: number,
+): React.Key | undefined {
+  if (typeof rowKey === 'function') {
+    return rowKey(record, index);
+  }
+  const value = record[rowKey] as unknown;
+  if (value == null) return undefined;
+  return typeof value === 'string' || typeof value === 'number' ? value : String(value);
+}
+
+/**
+ * Pixel-perfect snapshot of a rendered `<tr>` for the drag overlay clone.
+ * Contains everything needed to rebuild a visually identical floating row
+ * without re-running antd's column layout pass.
+ */
+export type RowSnapshot = {
+  /** outerHTML of the source `<tr>`, captured at drag start. */
+  html: string;
+  /** Per-cell pixel widths (in DOM order) so the clone can fix them via `<col>`. */
+  cellWidths: number[];
+  /** Total row width — used as the wrapper width so the clone matches source horizontally. */
+  totalWidth: number;
+  /** Total row height — applied to the clone so cell padding matches the source row exactly. */
+  totalHeight: number;
+};
+
+/**
+ * Snapshot the source `<tr>` so the drag overlay can render a pixel-accurate
+ * floating clone. We can't reliably recompute the layout from `columns` alone
+ * — antd auto-sizes columns at runtime based on content + the surrounding
+ * container — so we read the rendered widths off the DOM at drag start. The
+ * row height is captured too because antd's cell padding rules are scoped to
+ * a selector chain we strip in the clone.
+ */
+export function snapshotSourceRow(rowKey: string): RowSnapshot | null {
+  if (typeof document === 'undefined') return null;
+  // `CSS.escape` is in lib.dom and shipped in every browser we target; the
+  // guard is purely a belt-and-suspenders against exotic test environments
+  // where `window.CSS` may be absent.
+  const cssGlobal: { escape?: (value: string) => string } | undefined =
+    typeof window !== 'undefined' ? window.CSS : undefined;
+  const escaped = cssGlobal?.escape ? cssGlobal.escape(rowKey) : rowKey;
+  const sourceRow = document.querySelector(`tr[data-row-key="${escaped}"]`) as HTMLTableRowElement | null;
+  if (!sourceRow) return null;
+  const cellWidths = Array.from(sourceRow.cells).map((cell) => cell.getBoundingClientRect().width);
+  const rect = sourceRow.getBoundingClientRect();
+  return { html: sourceRow.outerHTML, cellWidths, totalWidth: rect.width, totalHeight: rect.height };
+}

package/src/components/index.ts

@@ -7,5 +7,12 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+export * from './AppComponents';
 export * from './BlankComponent';
+export * from './form/table/dnd';
+export * from './form';
+export * from './Icon';
+export * from './PoweredBy';
 export * from './RouterContextCleaner';
+export * from './SwitchLanguage';
+export * from './form/table';

package/src/css-variable/CSSVariableProvider.tsx

@@ -0,0 +1,117 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { TinyColor } from '@ctrl/tinycolor';
+import { useEffect } from 'react';
+import { theme } from 'antd';
+import { defaultTheme } from '../theme';
+import type { CustomToken } from '../theme';
+
+interface Result extends ReturnType<typeof theme.useToken> {
+  token: CustomToken;
+}
+
+export const CSSVariableProvider = ({ children }) => {
+  const { token } = theme.useToken() as Result;
+
+  const colorBgScrollTrack = token.colorFillTertiary;
+  const colorBgScrollBar = new TinyColor(token.colorFill).onBackground(token.colorFillSecondary).toHexShortString();
+  const colorBgScrollBarHover = new TinyColor(token.colorFill).onBackground(token.colorFill).toHexShortString();
+  const colorBgScrollBarActive = new TinyColor(token.colorFill)
+    .onBackground(token.colorFill)
+    .onBackground(token.colorFill)
+    .toHexShortString();
+
+  useEffect(() => {
+    document.body.style.setProperty('--nb-spacing', `${token.marginLG}px`);
+    document.body.style.setProperty('--nb-designer-offset', `${token.marginXS}px`);
+    document.body.style.setProperty('--nb-header-height', `${token.sizeXXL - 2}px`);
+    document.body.style.setProperty('--nb-box-bg', token.colorBgLayout);
+    document.body.style.setProperty('--colorBgLayout', token.colorBgLayout);
+    document.body.style.setProperty('--colorBgContainer', token.colorBgContainer);
+    document.body.style.setProperty('--controlHeightLG', `${token.controlHeightLG}px`);
+    document.body.style.setProperty('--paddingContentVerticalSM', `${token.paddingContentVerticalSM}px`);
+    document.body.style.setProperty('--marginSM', `${token.marginSM}px`);
+    document.body.style.setProperty('--colorInfoBg', token.colorInfoBg);
+    document.body.style.setProperty('--colorInfoBorder', token.colorInfoBorder);
+    document.body.style.setProperty('--colorWarningBg', token.colorWarningBg);
+    document.body.style.setProperty('--colorWarningBorder', token.colorWarningBorder);
+    document.body.style.setProperty('--colorText', token.colorText);
+    document.body.style.setProperty('--colorTextDescription', token.colorTextDescription);
+    document.body.style.setProperty('--colorBgTextHover', token.colorBgTextHover);
+    document.body.style.setProperty('--colorSplit', token.colorSplit);
+    document.body.style.setProperty('--borderRadiusOuter', `${token.borderRadiusOuter}px`);
+    document.body.style.setProperty('--colorTextHeaderMenu', token.colorTextHeaderMenu);
+    document.body.style.setProperty('--colorPrimaryText', token.colorPrimaryText);
+    document.body.style.setProperty('--colorPrimaryTextActive', token.colorPrimaryTextActive);
+    document.body.style.setProperty('--colorPrimaryTextHover', token.colorPrimaryTextHover);
+    // 侧边菜单栏相关CSS变量
+    document.body.style.setProperty('--colorBgSider', token.colorBgSider);
+    document.body.style.setProperty('--colorBgSiderMenuHover', token.colorBgSiderMenuHover);
+    document.body.style.setProperty('--colorBgSiderMenuActive', token.colorBgSiderMenuActive);
+    document.body.style.setProperty('--colorTextSiderMenu', token.colorTextSiderMenu);
+    document.body.style.setProperty('--colorTextSiderMenuHover', token.colorTextSiderMenuHover);
+    document.body.style.setProperty('--colorTextSiderMenuActive', token.colorTextSiderMenuActive);
+    document.body.style.setProperty('--colorBgScrollTrack', colorBgScrollTrack);
+    document.body.style.setProperty('--colorBgScrollBar', colorBgScrollBar);
+    document.body.style.setProperty('--colorBgScrollBarHover', colorBgScrollBarHover);
+    document.body.style.setProperty('--colorBgScrollBarActive', colorBgScrollBarActive);
+    document.body.style.setProperty('--colorSettings', token.colorSettings || defaultTheme.token.colorSettings);
+    document.body.style.setProperty('--colorBgSettingsHover', token.colorBgSettingsHover);
+    document.body.style.setProperty('--colorTemplateBgSettingsHover', token.colorTemplateBgSettingsHover);
+    document.body.style.setProperty('--colorBorderSettingsHover', token.colorBorderSettingsHover);
+    document.body.style.setProperty('--colorBgMenuItemSelected', token.colorBgHeaderMenuActive);
+
+    // 设置登录页面的背景色
+    document.body.style.setProperty('background-color', token.colorBgContainer);
+  }, [
+    colorBgScrollBar,
+    colorBgScrollBarActive,
+    colorBgScrollBarHover,
+    colorBgScrollTrack,
+    token.colorBgContainer,
+    token.colorBgLayout,
+    token.colorBgSettingsHover,
+    token.colorTemplateBgSettingsHover,
+    token.colorBorderSettingsHover,
+    token.colorInfoBg,
+    token.colorInfoBorder,
+    token.colorPrimaryText,
+    token.colorPrimaryTextActive,
+    token.colorPrimaryTextHover,
+    token.colorSettings,
+    token.colorBgTextHover,
+    token.colorSplit,
+    token.colorText,
+    token.colorTextDescription,
+    token.colorWarningBg,
+    token.colorWarningBorder,
+    token.borderRadiusOuter,
+    token.controlHeightLG,
+    token.marginLG,
+    token.marginSM,
+    token.marginXS,
+    token.paddingContentVerticalSM,
+    token.sizeXXL,
+    token.colorTextHeaderMenu,
+    token.colorBgSider,
+    token.colorBgSiderMenuHover,
+    token.colorBgSiderMenuActive,
+    token.colorTextSiderMenu,
+    token.colorTextSiderMenuHover,
+    token.colorTextSiderMenuActive,
+    token.colorBgHeaderMenuActive,
+  ]);
+
+  return children;
+};
+
+CSSVariableProvider.displayName = 'CSSVariableProvider';
+
+export default CSSVariableProvider;

package/src/data-source/ExtendCollectionsProvider.tsx

@@ -0,0 +1,144 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { CollectionOptions } from '@nocobase/flow-engine';
+import React, { FC, ReactNode, useEffect, useRef } from 'react';
+import { useApp } from '../hooks';
+
+export interface ExtendCollectionsProviderProps {
+  /** Data source key to extend. Defaults to `'main'`. */
+  dataSource?: string;
+  /** Collections to surface for the lifetime of this provider's subtree. */
+  collections: CollectionOptions[];
+  /**
+   * When `true`, re-sync the data source whenever the `collections` prop
+   * reference changes after mount: add entries newly present in the prop and
+   * remove entries no longer present (only those this provider registered).
+   * The diff runs in the same render as the prop change so children see the
+   * new state on their first render — at the cost of one observable mutation
+   * per change.
+   *
+   * Defaults to `false`. Most pages pass a stable (often module-level)
+   * `collections` list and don't need this; leaving it off avoids accidental
+   * re-registration when callers forget to memoize. Enable only when your
+   * collection list legitimately varies during the provider's lifetime.
+   */
+  syncOnChange?: boolean;
+  children?: ReactNode;
+}
+
+/**
+ * Mount-scoped collection injector. Adds the given `collections` to the target
+ * data source on first render — synchronously, so children can read
+ * `getCollection(name)` on their own first render — and removes them on
+ * unmount. Survives mid-session data-source reloads via the
+ * `dataSource:loaded` event by re-registering only the names this provider
+ * owns.
+ *
+ * Use this for client-only collections — e.g. a `schema-only` server
+ * collection that isn't auto-published to the v2 data source, or a pure
+ * UI-side mirror — so downstream components (like `<CollectionFilter>`) can
+ * resolve the collection by name.
+ *
+ * Default behavior is "static-at-mount": subsequent changes to the
+ * `collections` prop are ignored. Pass `syncOnChange` to opt into diffing on
+ * prop change.
+ */
+export const ExtendCollectionsProvider: FC<ExtendCollectionsProviderProps> = ({
+  dataSource = 'main',
+  collections,
+  syncOnChange = false,
+  children,
+}) => {
+  const app = useApp();
+  // Lazy-ref init guard. `ownedRef.current === null` only on the first render;
+  // once populated, StrictMode dev's second render and any subsequent
+  // re-render see a non-null ref and skip re-registering. React docs bless
+  // this idiom for "init exactly once on mount" — see "Avoiding recreating
+  // the ref contents".
+  const ownedRef = useRef<CollectionOptions[] | null>(null);
+  // Identity of the `collections` reference we last reacted to; gates the
+  // opt-in diff so StrictMode's double-render doesn't diff twice.
+  const lastCollectionsRef = useRef<CollectionOptions[] | null>(null);
+
+  if (ownedRef.current === null) {
+    const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+    const owned: CollectionOptions[] = [];
+    if (ds) {
+      for (const c of collections) {
+        if (ds.getCollection?.(c.name)) continue;
+        ds.addCollection?.(c);
+        owned.push(c);
+      }
+    }
+    ownedRef.current = owned;
+    lastCollectionsRef.current = collections;
+  } else if (syncOnChange && lastCollectionsRef.current !== collections) {
+    const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+    if (ds) {
+      const nextNames = new Set(collections.map((c) => c.name));
+      const prevOwned = new Map(ownedRef.current.map((c) => [c.name, c]));
+      for (const name of prevOwned.keys()) {
+        if (!nextNames.has(name)) ds.removeCollection?.(name);
+      }
+      const nextOwned: CollectionOptions[] = [];
+      for (const c of collections) {
+        const previous = prevOwned.get(c.name);
+        if (previous) {
+          // First-registered wins: keep the existing options object, mirroring
+          // the original behavior where re-adding a present name was a no-op.
+          // Callers who need to update a collection should remount the
+          // provider (e.g. `key={signature}`).
+          nextOwned.push(previous);
+          continue;
+        }
+        if (ds.getCollection?.(c.name)) continue;
+        ds.addCollection?.(c);
+        nextOwned.push(c);
+      }
+      ownedRef.current = nextOwned;
+    }
+    lastCollectionsRef.current = collections;
+  }
+
+  useEffect(() => {
+    const onLoaded = (event: Event) => {
+      const key = (event as CustomEvent<{ dataSourceKey: string }>).detail?.dataSourceKey;
+      if (key !== dataSource && key !== '*') return;
+      const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+      if (!ds || !ownedRef.current) return;
+      // dataSource was just reloaded from the server — our owned client-only
+      // entries got wiped. Re-add only the ones we own, using the snapshot in
+      // the ref so we don't accidentally seize names this provider never
+      // registered.
+      for (const c of ownedRef.current) {
+        if (ds.getCollection?.(c.name)) continue;
+        ds.addCollection?.(c);
+      }
+    };
+    app.eventBus?.addEventListener('dataSource:loaded', onLoaded);
+    return () => {
+      app.eventBus?.removeEventListener('dataSource:loaded', onLoaded);
+      const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+      const owned = ownedRef.current ?? [];
+      ownedRef.current = null;
+      lastCollectionsRef.current = null;
+      if (!ds) return;
+      for (const c of owned) ds.removeCollection?.(c.name);
+    };
+    // `collections` / `syncOnChange` intentionally excluded — they drive the
+    // render-phase init/diff above, not this effect. The listener reads
+    // `ownedRef` each time it fires (async, never during render).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [app, dataSource]);
+
+  return <>{children}</>;
+};
+
+export default ExtendCollectionsProvider;