packages/module-web/src/client/schema-initializer/items/RecordAssociationDetailsBlockInitializer.tsx (1)

25-37: Add consistent error handling

This component has the same async error handling issue as other initializers.

packages/module-web/src/client/schema-initializer/items/RecordAssociationGridCardBlockInitializer.tsx (1)

52-64: Apply consistent null checking pattern

Like other association block creators, this should include defensive null checks.

packages/module-web/src/client/schema-initializer/items/RecordAssociationFormBlockInitializer.tsx (1)

27-50: Add error handling for async template fetching.

Same issue as in RecordReadPrettyAssociationFormBlockInitializer - the async call could fail without proper error handling.

packages/client/src/schema-component/antd/action/index.tsx (1)

11-12: Export looks good – remember to re-export typings

The new named export matches existing usage in schema-initializer/components/CreateRecordAction.tsx.
Ensure linkageAction’s TypeScript types are also exported from ./utils to avoid any leakage.

packages/module-web/src/client/schema-initializer/components/assigned-field/index.ts (1)

1-1: Minor: maintain naming consistency

Elsewhere barrel files are named index.tsx; here it’s index.ts.
Not harmful, but using the same extension across packages avoids needless double compilation.

packages/module-web/src/client/schema-initializer/items/FilterBlockInitializer.tsx (1)

1-3: Consider documenting the alias relationship.

While the alias export pattern is syntactically correct, consider adding a comment explaining why FilterBlockInitializer is aliased to DataBlockInitializer. This would help future maintainers understand the relationship and prevent confusion about whether these should diverge in functionality.

+// FilterBlockInitializer is currently an alias for DataBlockInitializer
+// TODO: Consider if FilterBlockInitializer should have specialized behavior
 import { DataBlockInitializer } from './DataBlockInitializer';

 export const FilterBlockInitializer = DataBlockInitializer;

packages/module-web/src/client/schema-initializer/components/DeletedField.tsx (1)

5-5: Consider using CSS classes instead of inline styles.

For better maintainability and consistency with design systems, consider using CSS classes or styled components instead of inline styles.

-  return <div style={{ color: '#ccc' }}>{t('The field has been deleted')}</div>;
+  return <div className="deleted-field-message">{t('The field has been deleted')}</div>;

packages/module-web/src/client/schema-initializer/items/SubmitActionInitializer.tsx (1)

10-10: Consider removing or documenting the commented code.

The commented x-designer line should either be removed if it's no longer needed or documented with a TODO comment explaining why it's temporarily disabled.

-    // 'x-designer': 'Action.Designer',
+    // TODO: Re-enable when Action.Designer is available
+    // 'x-designer': 'Action.Designer',

packages/module-web/src/client/schema-initializer/items/G2PlotInitializer.tsx (1)

5-18: Consider adding error boundary or validation.

The component assumes useSchemaInitializerItem and useSchemaInitializer will always return valid objects. Consider adding basic validation to make the component more robust.

export const G2PlotInitializer = () => {
  const itemConfig = useSchemaInitializerItem();
  const { insert } = useSchemaInitializer();
+  
+  if (!itemConfig || !insert) {
+    return null;
+  }
+  
  return (
    <SchemaInitializerItem
      {...itemConfig}
      onClick={() => {
        insert({
          ...(itemConfig.schema || {}),
        });
      }}
    />
  );
};

packages/module-web/src/client/schema-initializer/items/CustomizeActionInitializer.tsx (2)

8-8: Clarify duplicate prop passing pattern.

The component passes itemConfig both as spread props ({...itemConfig}) and as an explicit item prop. This could lead to confusion or unintended prop overrides.

Consider clarifying the intent or removing redundancy:

-  return <BlockInitializer {...itemConfig} item={itemConfig} />;
+  return <BlockInitializer item={itemConfig} />;

Or if both patterns are needed, add a comment explaining why:

+  // Pass itemConfig as both spread props and item prop for BlockInitializer compatibility
   return <BlockInitializer {...itemConfig} item={itemConfig} />;

---

6-9: Consider adding error handling.

Like other initializer components, this could benefit from basic validation to handle cases where the hook returns undefined.

export const CustomizeActionInitializer = () => {
  const itemConfig = useSchemaInitializerItem();
+  
+  if (!itemConfig) {
+    return null;
+  }
+  
  return <BlockInitializer {...itemConfig} item={itemConfig} />;
};

packages/module-web/src/client/schema-initializer/hooks/useGetAriaLabelOfSchemaInitializer.ts (1)

12-12: Consider migrating from deprecated hook.

The hook uses useCollection_deprecated which suggests there's a newer version available. Consider updating to the non-deprecated alternative if available.

packages/module-web/src/client/schema-initializer/buttons/CustomFormItemInitializers.tsx (2)

10-10: Replace Chinese comment with English.

The comment should be in English for better maintainability in an international codebase.

-// 表单里配置字段
+// Configure fields in form

---

7-7: Consider adding type annotations for better maintainability.

The component lacks proper TypeScript type annotations which could help catch potential runtime errors.

-export const InitializerWithSwitch = (props) => {
+interface InitializerWithSwitchProps {
+  type: string;
+  schema?: any;
+  item: any;
+  remove?: () => void;
+  disabled?: boolean;
+}
+
+export const InitializerWithSwitch: React.FC<InitializerWithSwitchProps> = (props) => {

packages/module-web/src/client/schema-initializer/items/TableActionColumnInitializer.tsx (2)

7-34: Add proper TypeScript types for better maintainability.

The component lacks type annotations which could help prevent runtime errors and improve developer experience.

+interface TableActionColumnInitializerProps {
+  // Add props interface based on usage
+}
+
-export const TableActionColumnInitializer = () => {
+export const TableActionColumnInitializer: React.FC<TableActionColumnInitializerProps> = () => {

---

13-16: Consider making component properties configurable.

The hardcoded width and fixed position values could benefit from being configurable through props or context.

    'x-component-props': {
-     width: 150,
-     fixed: 'right',
+     width: props.width ?? 150,
+     fixed: props.fixed ?? 'right',
    },

packages/module-web/src/client/schema-initializer/items/SelectActionInitializer.tsx (2)

5-5: Add TypeScript interface for props.

The component lacks proper type annotations for its props.

+interface SelectActionInitializerProps {
+  [key: string]: any; // Based on ActionInitializer props
+}
+
-export const SelectActionInitializer = (props) => {
+export const SelectActionInitializer: React.FC<SelectActionInitializerProps> = (props) => {

---

6-59: Consider extracting large schema definition.

The schema object is quite large and complex. Consider extracting it to improve readability and reusability.

+const SELECT_ACTION_SCHEMA = {
+  type: 'void',
+  title: '{{ t("Select") }}',
+  'x-action': 'update',
+  // ... rest of schema
+};
+
export const SelectActionInitializer: React.FC<SelectActionInitializerProps> = (props) => {
-  const schema = {
-    type: 'void',
-    title: '{{ t("Select") }}',
-    // ... large schema object
-  };
-  return <ActionInitializer {...props} schema={schema} />;
+  return <ActionInitializer {...props} schema={SELECT_ACTION_SCHEMA} />;
};

packages/module-web/src/client/schema-initializer/buttons/SubTableActionInitializers.tsx (1)

3-35: Consider adding type annotations for the schema initializer configuration.

While the current configuration works, adding proper TypeScript types would improve maintainability and catch potential configuration errors.

+import type { SchemaInitializerOptions } from '@tachybase/client';
+
+const subTableActionInitializerConfig: SchemaInitializerOptions = {
  name: 'subTable:configureActions',
  title: "{{t('Configure actions')}}",
  icon: 'SettingOutlined',
  // ... rest of configuration
+};
+
-export const subTableActionInitializers = new SchemaInitializer({
-  name: 'subTable:configureActions',
-  // ... configuration
-});
+export const subTableActionInitializers = new SchemaInitializer(subTableActionInitializerConfig);

packages/module-web/src/client/schema-initializer/items/BlockInitializer.tsx (1)

15-15: Add error handling for optional method calls.

The optional chaining for item?.schemaInitialize?.(s) is good, but consider adding error handling in case the method throws an exception.

        const s = merge(schema || {}, item.schema || {});
-       item?.schemaInitialize?.(s);
+       try {
+         item?.schemaInitialize?.(s);
+       } catch (error) {
+         console.error('Schema initialization failed:', error);
+       }
        insert(s);

packages/module-web/src/client/schema-initializer/items/RecordAssociationListBlockInitializer.tsx (1)

23-23: Icon doesn't match the block type

The component uses TableOutlined icon for a List block initializer. Consider using a more appropriate icon like UnorderedListOutlined or OrderedListOutlined to better represent the list block type.

-      icon={<TableOutlined />}
+      icon={<UnorderedListOutlined />}

Don't forget to import the new icon:

-import { TableOutlined } from '@ant-design/icons';
+import { UnorderedListOutlined } from '@ant-design/icons';

packages/module-web/src/client/schema-initializer/SchemaInitializerPlugin.ts (1)

3-63: Clean up commented imports

There are 60+ lines of commented imports. If these are planned features, consider adding a TODO comment explaining the timeline. If they're no longer needed, remove them to improve code clarity.

Would you like me to help identify which of these commented imports are still needed based on the current codebase?

packages/module-web/src/client/schema-initializer/items/RecordAssociationDetailsBlockInitializer.tsx (1)

22-22: Consider more appropriate icon for Details block

Using FormOutlined for a Details block might be misleading. Consider using FileTextOutlined or ProfileOutlined which better represents detail views.

-      icon={<FormOutlined />}
+      icon={<FileTextOutlined />}

packages/client/src/schema-settings/VariableInput/hooks/useBaseVariable.tsx (1)

151-206: Consider using requestIdleCallback instead of setTimeout

Using setTimeout with a 5ms delay to prevent UI blocking is a workaround. Consider using requestIdleCallback for better performance optimization or proper async handling.

     return new Promise((resolve) => {
-      setTimeout(() => {
+      const processChildren = () => {
         const children = (
           getChildren(returnFields(getFilterOptions(target, dataSource), option), {
             // ... parameters
           }) || []
         )
         // ... sorting logic
         
         if (children.length === 0) {
           option.disabled = true;
           option.isLeaf = true;
           resolve();
           return;
         }
         option.children = children;
         resolve();
-      }, 5);
+      };
+      
+      if ('requestIdleCallback' in window) {
+        requestIdleCallback(processChildren);
+      } else {
+        setTimeout(processChildren, 0);
+      }
     });

packages/module-web/src/client/schema-initializer/items/RecordAssociationGridCardBlockInitializer.tsx (1)

26-26: Icon consistency for GridCard

Using TableOutlined for a GridCard block. Consider using AppstoreOutlined which better represents a grid/card layout.

-      icon={<TableOutlined />}
+      icon={<AppstoreOutlined />}

packages/module-web/src/client/schema-initializer/items/RecordReadPrettyAssociationFormBlockInitializer.tsx (1)

61-103: Consider extracting shared schema creation logic.

There's significant code duplication between the component's onClick handler and the hook's callbacks. Both implement similar logic for creating details UI schemas with templates.

Consider extracting the shared logic into a utility function:

function createDetailsSchemaWithTemplate(params: {
  collection: any;
  association: string;
  templateSchema?: any;
  mode?: string;
  componentName?: string;
}) {
  const { collection, association, templateSchema, mode, componentName } = params;
  
  if (templateSchema && componentName === 'ReadPrettyFormItem') {
    const blockSchema = createDetailsUISchema({
      dataSource: collection.dataSource,
      association,
      templateSchema,
    });
    if (mode === 'reference') {
      blockSchema['x-template-key'] = templateSchema.key;
    }
    return blockSchema;
  }
  
  return templateSchema || createDetailsUISchema({
    dataSource: collection.dataSource,
    association,
  });
}

This would reduce duplication and make the code more maintainable.

packages/module-web/src/client/schema-initializer/buttons/RecordBlockInitializers.tsx (1)

357-366: Remove commented code.

Commented-out code should be removed to keep the codebase clean. Version control preserves the history if needed.

-    // {
-    //   type: 'itemGroup',
-    //   name: 'relationshipBlocks',
-    //   title: '{{t("Relationship blocks")}}',
-    //   useChildren: useRelationFields,
-    //   useVisible() {
-    //     const res = useRelationFields();
-    //     return res.length > 0;
-    //   },
-    // },

packages/module-web/src/client/schema-initializer/buttons/FormItemInitializers.tsx (3)

23-32: Use map instead of forEach with push.

The current pattern of using forEach with push can be simplified using map and filter.

-  const res = [];
-  inheritFields.forEach((inherit) => {
-    Object.values(inherit)[0].length &&
-      res.push({
-        type: 'itemGroup',
-        divider: true,
-        title: t(`Parent collection fields`) + '(' + compile(`${Object.keys(inherit)[0]}`) + ')',
-        children: Object.values(inherit)[0],
-      });
-  });
+  const res = inheritFields
+    .filter((inherit) => Object.values(inherit)[0].length > 0)
+    .map((inherit) => ({
+      type: 'itemGroup',
+      divider: true,
+      title: t(`Parent collection fields`) + '(' + compile(`${Object.keys(inherit)[0]}`) + ')',
+      children: Object.values(inherit)[0],
+    }));

---

70-81: Simplify nested ternary operators for better readability.

The nested ternary operators make the code hard to read and maintain.

-'x-component-props': isFileCollection
-  ? {
-      fieldNames: {
-        label: 'preview',
-        value: 'id',
-      },
-    }
-  : isAssociationField && fieldNames
-    ? {
-        fieldNames: { ...fieldNames, label: targetCollection?.titleField || fieldNames.label },
-      }
-    : {},
+'x-component-props': (() => {
+  if (isFileCollection) {
+    return {
+      fieldNames: {
+        label: 'preview',
+        value: 'id',
+      },
+    };
+  }
+  if (isAssociationField && fieldNames) {
+    return {
+      fieldNames: { 
+        ...fieldNames, 
+        label: targetCollection?.titleField || fieldNames.label 
+      },
+    };
+  }
+  return {};
+})(),

---

136-145: Use map for consistency with suggested refactoring.

Apply the same map pattern for consistency if the previous suggestion is accepted.

-  const res = [];
-  if (inheritFields?.length > 0) {
-    inheritFields.forEach((inherit) => {
-      Object.values(inherit)[0].length &&
-        res.push({
-          divider: true,
-          type: 'itemGroup',
-          title: t(`Parent collection fields`) + '(' + compile(`${Object.keys(inherit)[0]}`) + ')',
-          children: Object.values(inherit)[0],
-        });
-    });
-  }
+  const res = inheritFields?.length > 0
+    ? inheritFields
+        .filter((inherit) => Object.values(inherit)[0].length > 0)
+        .map((inherit) => ({
+          divider: true,
+          type: 'itemGroup',
+          title: t(`Parent collection fields`) + '(' + compile(`${Object.keys(inherit)[0]}`) + ')',
+          children: Object.values(inherit)[0],
+        }))
+    : [];

packages/module-web/src/client/schema-initializer/components/CreateRecordAction.tsx (2)

25-102: Consolidate duplicate style definitions.

The designer and actionDesigner styles are nearly identical. Consider extracting common styles.

const useStyles = createStyles(({ css }) => {
  const commonStyle = css`
    position: relative;
    &:hover {
      .general-schema-designer {
        display: block;
      }
    }
    .general-schema-designer {
      position: absolute;
      z-index: 999;
      top: 0;
      bottom: 0;
      left: 0;
      right: 0;
      display: none;
      background: var(--colorBgSettingsHover);
      border: 0;
      pointer-events: none;
      > .general-schema-designer-icons {
        position: absolute;
        right: 2px;
        top: 2px;
        line-height: 16px;
        pointer-events: all;
        .ant-space-item {
          background-color: var(--colorSettings);
          color: #fff;
          line-height: 16px;
          width: 16px;
          padding-left: 1px;
          align-self: stretch;
        }
      }
    }
  `;
  
  return {
    designer: commonStyle,
    actionDesigner: commonStyle,
  };
});

---

383-383: Update function call to match suggested rename.

If the getLinkageCollection function is renamed as suggested, update the call here.

-          const collectionName = getLinkageCollection(linkageFromForm, form, field);
+          const collectionName = parseLinkageCollectionVariable(linkageFromForm, form, field);

packages/module-web/src/client/schema-initializer/components/assigned-field/AssignedField.tsx (3)

60-62: Remove commented code

Dead code should be removed to improve code maintainability.

-    // if (!field.validator && uiSchema['x-validator']) {
-    //   field.validator = uiSchema['x-validator'];
-    // }

---

76-76: Optimize useEffect dependency

Using JSON.stringify(uiSchema) in the dependency array is inefficient as it runs on every render. Consider using a deep comparison hook or memoizing the stringified value.

-  }, [JSON.stringify(uiSchema)]);
+  }, [uiSchema]);

If deep comparison is needed, consider using a custom hook like useDeepCompareEffect or memoizing the value:

const uiSchemaKey = useMemo(() => JSON.stringify(uiSchema), [uiSchema]);
useEffect(() => {
  // effect logic
}, [uiSchemaKey]);

---

136-136: Optimize dependency array in useCallback

Using JSON.stringify with _.omit in the dependency array is inefficient and runs on every render.

Consider memoizing the filtered props:

const memoizedProps = useMemo(() => _.omit(props, 'value'), [props]);

const renderSchemaComponent = useCallback(
  ({ value, onChange }): React.JSX.Element => {
    return <CollectionField {...props} value={value} onChange={onChange} />;
  },
  [memoizedProps],
);

packages/module-web/src/client/schema-initializer/items/DataBlockInitializer.tsx (2)

103-105: Replace delete operator with undefined assignment

The delete operator can impact performance. Use undefined assignment instead.

-        delete container.style.height;
+        container.style.height = undefined;

---

116-126: Add return type annotation for hook

The hook should have a proper return type for better type safety.

-export function useMenuSearch({
+export function useMenuSearch({
   data,
   openKeys,
   showType,
   hideSearch,
 }: {
   data: any[];
   openKeys: string[];
   showType?: boolean;
   hideSearch?: boolean;
-}) {
+}): MenuProps['items'] {

packages/module-web/src/client/schema-initializer/items/CustomFilterFormItemInitializer.tsx (1)

162-322: Refactor long handleClick function

This function is very long (160 lines) and handles multiple responsibilities. Consider breaking it down into smaller, more focused functions.

Consider extracting the schema generation and dialog configuration into separate functions:

const createFieldSchema = (values, cm, getInterface) => {
  const { title, component, collection, associationField, props } = values;
  const defaultSchema = getInterface(component)?.default?.uiSchema || {};
  const titleField = cm.getCollection(collection)?.titleField;
  const name = uid();
  
  return {
    ...defaultSchema,
    type: 'string',
    title: title,
    name: '__custom.' + name,
    // ... rest of schema
  };
};

const createDialogSchema = (fieldComponents, allCollection, t) => {
  return {
    properties: {
      name: { type: 'string', required: true },
      // ... rest of properties
    }
  };
};

packages/module-web/src/client/schema-initializer/buttons/TabPaneInitializers.tsx (1)

30-36: Replace delete operators with undefined assignments

Using the delete operator can impact performance. Assign undefined instead.

        const deleteUid = (s: ISchema) => {
-          delete s['name'];
-          delete s['x-uid'];
+          s['name'] = undefined;
+          s['x-uid'] = undefined;
          Object.keys(s.properties || {}).forEach((key) => {
            deleteUid(s.properties[key]);
          });
        };

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro