refactor: flip to caseSensitive (default is case-insensitive)

- Rename caseInsensitive -> caseSensitive on Filter type and options
- Default behavior (caseSensitive=false or unset via UI) uses regex (?i)
- Checkbox now labeled 'Case sensitive'; checking it opts into exact match
- Only triggers regex when caseSensitive is explicitly false (backward compat)

Author: IzumiSy

packages/core/src/components/data-table/i18n.ts

@@ -50,7 +50,7 @@ export const dataTableLabels = defineI18nLabels({
     filterOperator_between: "between",
     filterOperator_in: "in",
     filterOperator_nin: "not in",
-    filterCaseInsensitive: "Case insensitive",
+    filterCaseSensitive: "Case sensitive",
 
     // Filter chip label templates
     filterChipLabel: (props: { column: string; operator: string; value: string }) =>
@@ -98,7 +98,7 @@ export const dataTableLabels = defineI18nLabels({
     filterOperator_between: "の範囲内",
     filterOperator_in: "次のいずれか",
     filterOperator_nin: "次のいずれでもない",
-    filterCaseInsensitive: "大文字小文字を区別しない",
+    filterCaseSensitive: "大文字小文字を区別する",
 
     // Filter chip label templates (Japanese: column: value operator)
     filterChipLabel: (props: { column: string; operator: string; value: string }) =>

packages/core/src/components/data-table/toolbar.test.tsx

@@ -240,7 +240,7 @@ describe("StringFilterEditor", () => {
     await user.click(screen.getByRole("button", { name: "Apply" }));
 
     expect(control.addFilter).toHaveBeenCalledWith("name", "contains", "Bob", {
-      caseInsensitive: false,
+      caseSensitive: false,
     });
   });
 
@@ -261,7 +261,7 @@ describe("StringFilterEditor", () => {
     await user.keyboard("{Enter}");
 
     expect(control.addFilter).toHaveBeenCalledWith("name", "contains", "Charlie", {
-      caseInsensitive: false,
+      caseSensitive: false,
     });
   });
 
@@ -283,7 +283,7 @@ describe("StringFilterEditor", () => {
     expect(control.removeFilter).toHaveBeenCalledWith("name");
   });
 
-  it("shows a Case insensitive checkbox", async () => {
+  it("shows a Case sensitive checkbox", async () => {
     const user = userEvent.setup();
     const control = makeControl({
       filters: [{ field: "name", operator: "contains", value: "Alice" }],
@@ -294,10 +294,10 @@ describe("StringFilterEditor", () => {
 
     await user.click(screen.getByRole("button", { name: /Name contains Alice/ }));
 
-    expect(await screen.findByText("Case insensitive")).toBeDefined();
+    expect(await screen.findByText("Case sensitive")).toBeDefined();
   });
 
-  it("Apply with case-insensitive checked calls addFilter with caseInsensitive option", async () => {
+  it("Apply with case-sensitive checked calls addFilter with caseSensitive option", async () => {
     const user = userEvent.setup();
     const control = makeControl({
       filters: [{ field: "name", operator: "contains", value: "Alice" }],
@@ -314,14 +314,14 @@ describe("StringFilterEditor", () => {
     await user.click(screen.getByRole("button", { name: "Apply" }));
 
     expect(control.addFilter).toHaveBeenCalledWith("name", "contains", "Alice", {
-      caseInsensitive: true,
+      caseSensitive: true,
     });
   });
 
-  it("restores case-insensitive state from existing filter", async () => {
+  it("restores case-sensitive state from existing filter", async () => {
     const user = userEvent.setup();
     const control = makeControl({
-      filters: [{ field: "name", operator: "contains", value: "Alice", caseInsensitive: true }],
+      filters: [{ field: "name", operator: "contains", value: "Alice", caseSensitive: true }],
     });
     render(<TestFilters control={control} columns={[stringColumn]} />, {
       wrapper,

packages/core/src/components/data-table/toolbar.tsx

@@ -120,7 +120,7 @@ function AddFilterPopover({
   const [field, setField] = useState<string | null>(null);
   const [operator, setOperator] = useState<FilterOperator>("eq");
   const [value, setValue] = useState<AddFilterDraftValue>("");
-  const [caseInsensitive, setCaseInsensitive] = useState(false);
+  const [caseSensitive, setCaseSensitive] = useState(false);
 
   const fieldLabelMap = useMemo(
     () => new Map(availableColumns.map((col) => [col.filter.field, col.label ?? col.filter.field])),
@@ -146,14 +146,14 @@ function AddFilterPopover({
       setField(null);
       setOperator("eq");
       setValue("");
-      setCaseInsensitive(false);
+      setCaseSensitive(false);
       return;
     }
 
     setField(column.filter.field);
     setOperator(DEFAULT_OPERATOR[column.filter.type]);
     setValue(getInitialAddFilterDraftValue(column.filter.type));
-    setCaseInsensitive(false);
+    setCaseSensitive(false);
   }, []);
 
   const handleOpenChange = useCallback(
@@ -177,7 +177,7 @@ function AddFilterPopover({
       setField(nextField);
       setOperator(DEFAULT_OPERATOR[nextColumn.filter.type]);
       setValue(getInitialAddFilterDraftValue(nextColumn.filter.type));
-      setCaseInsensitive(false);
+      setCaseSensitive(false);
     },
     [availableColumns],
   );
@@ -190,10 +190,10 @@ function AddFilterPopover({
       selectedColumn.filter.field,
       operator,
       toAddFilterSubmittedValue(selectedColumn.filter.type, value),
-      selectedColumn.filter.type === "string" ? { caseInsensitive } : undefined,
+      selectedColumn.filter.type === "string" ? { caseSensitive } : undefined,
     );
     setOpen(false);
-  }, [selectedColumn, value, operator, caseInsensitive, control]);
+  }, [selectedColumn, value, operator, caseSensitive, control]);
 
   const renderValueEditor = () => {
     if (!selectedColumn) return null;
@@ -354,15 +354,15 @@ function AddFilterPopover({
               {selectedColumn?.filter.type === "string" && (
                 <label className="astw:flex astw:items-center astw:gap-1.5 astw:text-sm">
                   <Checkbox.Root
-                    checked={caseInsensitive}
-                    onCheckedChange={setCaseInsensitive}
+                    checked={caseSensitive}
+                    onCheckedChange={setCaseSensitive}
                     className="astw:flex astw:size-4 astw:items-center astw:justify-center astw:rounded-sm astw:border astw:border-input data-[checked]:astw:border-primary data-[checked]:astw:bg-primary data-[checked]:astw:text-primary-foreground"
                   >
                     <Checkbox.Indicator className="astw:flex astw:items-center astw:justify-center">
                       <Check className="astw:size-3" />
                     </Checkbox.Indicator>
                   </Checkbox.Root>
-                  {t("filterCaseInsensitive")}
+                  {t("filterCaseSensitive")}
                 </label>
               )}
               <Button
@@ -662,18 +662,18 @@ function StringFilterEditor({
       : "contains",
   );
   const [localValue, setLocalValue] = useState(String(filter.value ?? ""));
-  const [localCaseInsensitive, setLocalCaseInsensitive] = useState(filter.caseInsensitive ?? false);
+  const [localCaseSensitive, setLocalCaseSensitive] = useState(filter.caseSensitive ?? false);
 
   const handleCommit = useCallback(() => {
     if (localValue.trim() === "") {
       control.removeFilter(config.field);
     } else {
       control.addFilter(config.field, localOp, localValue, {
-        caseInsensitive: localCaseInsensitive,
+        caseSensitive: localCaseSensitive,
       });
     }
     onClose();
-  }, [localValue, localOp, localCaseInsensitive, control, config.field, onClose]);
+  }, [localValue, localOp, localCaseSensitive, control, config.field, onClose]);
 
   return (
     <div
@@ -699,15 +699,15 @@ function StringFilterEditor({
       />
       <label className="astw:flex astw:items-center astw:gap-1.5 astw:text-sm">
         <Checkbox.Root
-          checked={localCaseInsensitive}
-          onCheckedChange={setLocalCaseInsensitive}
+          checked={localCaseSensitive}
+          onCheckedChange={setLocalCaseSensitive}
           className="astw:flex astw:size-4 astw:items-center astw:justify-center astw:rounded-sm astw:border astw:border-input data-[checked]:astw:border-primary data-[checked]:astw:bg-primary data-[checked]:astw:text-primary-foreground"
         >
           <Checkbox.Indicator className="astw:flex astw:items-center astw:justify-center">
             <Check className="astw:size-3" />
           </Checkbox.Indicator>
         </Checkbox.Root>
-        {t("filterCaseInsensitive")}
+        {t("filterCaseSensitive")}
       </label>
       <Button size="xs" onClick={handleCommit} className="astw:self-end">
         {t("applyFilter")}
@@ -1076,7 +1076,7 @@ function getChipDisplayLabel(
   if (!valueLabel) return columnLabel;
 
   const operatorLabel = getOperatorLabel(filter.operator, t);
-  const ciSuffix = filter.caseInsensitive ? " (Aa)" : "";
+  const ciSuffix = filter.caseSensitive ? " (Aa)" : "";
 
   if (config.type === "enum") {
     return t("filterChipLabelEnum", {

packages/core/src/hooks/use-collection-variables.test.ts

@@ -162,32 +162,32 @@ describe("useCollectionVariables", () => {
       expect(result.current.variables.pagination).toEqual({ first: 20 });
     });
 
-    it("adds a case-insensitive filter and converts to regex in query variables", () => {
+    it("string filter defaults to case-insensitive regex in query variables", () => {
       const { result } = renderHook(() => useCollectionVariables({}));
 
       act(() => {
         result.current.control.addFilter("name", "contains", "Alice", {
-          caseInsensitive: true,
+          caseSensitive: false,
         });
       });
 
       expect(result.current.control.filters[0]).toMatchObject({
         field: "name",
         operator: "contains",
         value: "Alice",
-        caseInsensitive: true,
+        caseSensitive: false,
       });
       expect(result.current.variables.query).toEqual({
         name: { regex: "(?i)Alice" },
       });
     });
 
-    it("converts eq operator to regex with anchors when case-insensitive", () => {
+    it("converts eq operator to regex with anchors when caseSensitive is false", () => {
       const { result } = renderHook(() => useCollectionVariables({}));
 
       act(() => {
         result.current.control.addFilter("name", "eq", "Alice", {
-          caseInsensitive: true,
+          caseSensitive: false,
         });
       });
 
@@ -196,12 +196,12 @@ describe("useCollectionVariables", () => {
       });
     });
 
-    it("converts hasPrefix operator to regex when case-insensitive", () => {
+    it("converts hasPrefix operator to regex when caseSensitive is false", () => {
       const { result } = renderHook(() => useCollectionVariables({}));
 
       act(() => {
         result.current.control.addFilter("name", "hasPrefix", "Al", {
-          caseInsensitive: true,
+          caseSensitive: false,
         });
       });
 
@@ -210,12 +210,12 @@ describe("useCollectionVariables", () => {
       });
     });
 
-    it("converts hasSuffix operator to regex when case-insensitive", () => {
+    it("converts hasSuffix operator to regex when caseSensitive is false", () => {
       const { result } = renderHook(() => useCollectionVariables({}));
 
       act(() => {
         result.current.control.addFilter("name", "hasSuffix", "ce", {
-          caseInsensitive: true,
+          caseSensitive: false,
         });
       });
 
@@ -229,7 +229,7 @@ describe("useCollectionVariables", () => {
 
       act(() => {
         result.current.control.addFilter("name", "contains", "a.b*c", {
-          caseInsensitive: true,
+          caseSensitive: false,
         });
       });
 
@@ -238,12 +238,12 @@ describe("useCollectionVariables", () => {
       });
     });
 
-    it("uses original operator when caseInsensitive is false", () => {
+    it("uses original operator when caseSensitive is true", () => {
       const { result } = renderHook(() => useCollectionVariables({}));
 
       act(() => {
         result.current.control.addFilter("name", "contains", "Alice", {
-          caseInsensitive: false,
+          caseSensitive: true,
         });
       });
 

packages/core/src/hooks/use-collection-variables.ts

@@ -161,15 +161,15 @@ export function useCollectionVariables(
       field: string,
       operator: FilterOperator,
       value: unknown,
-      filterOptions?: { caseInsensitive?: boolean },
+      filterOptions?: { caseSensitive?: boolean },
     ) => {
       setFiltersState((prev) => {
         const existing = prev.findIndex((f) => f.field === field);
         const newFilter: Filter = {
           field,
           operator,
           value,
-          caseInsensitive: filterOptions?.caseInsensitive,
+          caseSensitive: filterOptions?.caseSensitive,
         };
         if (existing >= 0) {
           const updated = [...prev];
@@ -234,7 +234,7 @@ export function useCollectionVariables(
     if (filters.length === 0) return undefined;
     const filterQuery: Record<string, Record<string, unknown>> = {};
     for (const filter of filters) {
-      if (filter.caseInsensitive && typeof filter.value === "string") {
+      if (filter.caseSensitive === false && typeof filter.value === "string") {
         filterQuery[filter.field] = {
           regex: toCaseInsensitiveRegex(filter.operator, filter.value),
         };

packages/core/src/types/collection.ts

@@ -180,7 +180,7 @@ export interface Filter<TFieldName extends string = string> {
   field: TFieldName;
   operator: FilterOperator;
   value: unknown;
-  caseInsensitive?: boolean;
+  caseSensitive?: boolean;
 }
 
 /**
@@ -197,7 +197,7 @@ export type TableMetadataFilter<TTable extends TableMetadata> =
                 field: N;
                 operator: OperatorForFilterType[FieldTypeToFilterConfigType[T]];
                 value: unknown;
-                caseInsensitive?: boolean;
+                caseSensitive?: boolean;
               }
           : never
         : never
@@ -378,7 +378,7 @@ export interface CollectionControl<
     field: F,
     operator: OperatorForField<TFilter, F>,
     value: unknown,
-    options?: { caseInsensitive?: boolean },
+    options?: { caseSensitive?: boolean },
   ): void;
   setFilters: (filters: Filter<TFieldName>[]) => void;
   removeFilter(field: TFieldName): void;