@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/content/app/components/editor/database/filter-sort.ts

@@ -1,33 +1,23 @@
 // i18n-raw-literal-disable-file -- unused pure helper copy; live database editor owns localized UI.
-// Filter/sort logic: apply, upsert, move, match, property value helpers.
+// Filter/sort helpers: apply, upsert, quick filters, property values.
 // Pure logic — no React, no icons.
 import type {
   ContentDatabaseItem,
   DocumentProperty,
   DocumentPropertyType,
-  DocumentPropertyValue,
 } from "@shared/api";
-import { formulaValueText, isComputedPropertyType } from "@shared/properties";
+import { applyContentDatabaseTableQuery } from "@shared/database-query";
+import { formulaValueText } from "@shared/properties";
 
-import { propertyDateValue } from "./calendar-timeline";
 import {
   type ColumnKey,
-  type DatabaseConditionMoveDirection,
   type DatabaseFilter,
   type DatabaseFilterMode,
   type DatabaseQuickFilterOperator,
-  type DatabaseRowDensity,
   type FilterOperator,
   type SortDirection,
   type DatabaseSort,
 } from "./types";
-export {
-  normalizeClientDatabaseFilterMode,
-  normalizeClientDatabaseRowDensity,
-  normalizeClientDatabaseOpenPagesIn,
-} from "./view-config";
-
-export { type DatabaseConditionMoveDirection };
 
 const DATABASE_QUICK_FILTER_OPERATORS: FilterOperator[] = [
   "is_empty",
@@ -44,104 +34,14 @@ export function applyDatabaseView(
   sorts: DatabaseSort[],
   filterMode: DatabaseFilterMode = "and",
 ) {
-  const query = searchQuery.trim().toLowerCase();
-  const searched = query
-    ? items.filter((item) =>
-        databaseItemSearchText(item, properties).toLowerCase().includes(query),
-      )
-    : items;
-  const activeFilters = filters.filter(isActiveFilter);
-  const filtered = activeFilters.length
-    ? searched.filter((item) =>
-        databaseItemMatchesFilterTree(
-          item,
-          properties,
-          activeFilters,
-          filterMode,
-        ),
-      )
-    : searched;
-
-  if (sorts.length === 0) return filtered;
-
-  return [...filtered].sort((a, b) => {
-    for (const sort of sorts) {
-      const comparison = compareDatabaseSortValues(
-        databaseItemSortValue(a, properties, sort.key),
-        databaseItemSortValue(b, properties, sort.key),
-      );
-      if (comparison !== 0) {
-        return sort.direction === "asc" ? comparison : -comparison;
-      }
-    }
-    return 0;
+  return applyContentDatabaseTableQuery(items, properties, {
+    search: searchQuery,
+    filters,
+    sorts,
+    filterMode,
   });
 }
 
-function databaseItemMatchesFilterTree(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  filters: DatabaseFilter[],
-  filterMode: DatabaseFilterMode,
-) {
-  const rootFilters = filters.filter((filter) => !filter.parentFilterGroupId);
-  const nestedGroups = nestedDatabaseFilterGroups(filters);
-  const matches = [
-    ...rootFilters.map((filter) =>
-      databaseItemMatchesFilter(item, properties, filter),
-    ),
-    ...nestedGroups.map((group) =>
-      combineDatabaseFilterMatches(
-        group.map((filter) =>
-          databaseItemMatchesFilter(item, properties, filter),
-        ),
-        filterMode,
-      ),
-    ),
-  ];
-
-  return combineDatabaseFilterMatches(matches, filterMode);
-}
-
-function nestedDatabaseFilterGroups(filters: DatabaseFilter[]) {
-  const groups = new Map<string, DatabaseFilter[]>();
-  for (const filter of filters) {
-    if (!filter.parentFilterGroupId || !filter.filterGroupId) continue;
-    groups.set(filter.filterGroupId, [
-      ...(groups.get(filter.filterGroupId) ?? []),
-      filter,
-    ]);
-  }
-  return [...groups.values()].filter((group) => group.length > 0);
-}
-
-function combineDatabaseFilterMatches(
-  matches: boolean[],
-  filterMode: DatabaseFilterMode,
-) {
-  if (matches.length === 0) return true;
-  return filterMode === "or"
-    ? matches.some((matched) => matched)
-    : matches.every((matched) => matched);
-}
-
-export function defaultDatabaseSort(): DatabaseSort {
-  return {
-    key: "name",
-    label: "Name",
-    direction: "asc",
-  };
-}
-
-export function defaultDatabaseFilter(): DatabaseFilter {
-  return {
-    key: "name",
-    label: "Name",
-    operator: "contains",
-    value: "",
-  };
-}
-
 export function upsertDatabaseSort(
   sorts: DatabaseSort[],
   key: ColumnKey,
@@ -158,48 +58,6 @@ export function clearDatabaseSort(sorts: DatabaseSort[], key: ColumnKey) {
   return sorts.filter((sort) => sort.key !== key);
 }
 
-export function moveDatabaseSort(
-  sorts: DatabaseSort[],
-  index: number,
-  direction: DatabaseConditionMoveDirection,
-) {
-  return moveDatabaseCondition(sorts, index, direction);
-}
-
-export function appendDatabaseFilter(
-  filters: DatabaseFilter[],
-  key: ColumnKey,
-  label: string,
-  operator: FilterOperator,
-  value = "",
-) {
-  return [...filters, { key, label, operator, value }];
-}
-
-export function moveDatabaseFilter(
-  filters: DatabaseFilter[],
-  index: number,
-  direction: DatabaseConditionMoveDirection,
-) {
-  return moveDatabaseCondition(filters, index, direction);
-}
-
-function moveDatabaseCondition<T>(
-  items: T[],
-  index: number,
-  direction: DatabaseConditionMoveDirection,
-) {
-  const targetIndex = direction === "up" ? index - 1 : index + 1;
-  if (index < 0 || targetIndex < 0 || targetIndex >= items.length) {
-    return items;
-  }
-
-  const next = [...items];
-  next[index] = items[targetIndex];
-  next[targetIndex] = items[index];
-  return next;
-}
-
 export function databaseQuickFilterOptionsForColumn(
   propertyType?: DocumentPropertyType,
 ): Array<{ operator: DatabaseQuickFilterOperator; label: string }> {
@@ -238,357 +96,6 @@ export function clearDatabaseFiltersForColumn(
   return filters.filter((filter) => filter.key !== key);
 }
 
-export function databaseColumnHeaderState(
-  sorts: DatabaseSort[],
-  filters: DatabaseFilter[],
-  key: ColumnKey,
-) {
-  const sort = sorts.find((candidate) => candidate.key === key);
-  return {
-    sortDirection: sort?.direction ?? null,
-    activeFilterCount: filters.filter(
-      (filter) => filter.key === key && isActiveFilter(filter),
-    ).length,
-  };
-}
-
-function databaseColumnHeaderStateLabel(
-  state: ReturnType<typeof databaseColumnHeaderState>,
-) {
-  const parts = [
-    state.sortDirection
-      ? `Sorted ${state.sortDirection === "asc" ? "ascending" : "descending"}`
-      : "",
-    state.activeFilterCount > 0
-      ? `${state.activeFilterCount} active filter${state.activeFilterCount === 1 ? "" : "s"}`
-      : "",
-  ].filter(Boolean);
-  return parts.join(", ");
-}
-
-export { databaseColumnHeaderStateLabel };
-
-export function activeDatabaseConstraintCount(
-  searchQuery: string,
-  sorts: DatabaseSort[],
-  filters: DatabaseFilter[],
-) {
-  return (
-    (searchQuery.trim() ? 1 : 0) +
-    sorts.length +
-    filters.filter(isActiveFilter).length
-  );
-}
-
-export function isActiveFilter(
-  filter: DatabaseFilter | null,
-): filter is DatabaseFilter {
-  if (!filter) return false;
-  if (filterOperatorNeedsValue(filter.operator)) {
-    return filter.value.trim().length > 0;
-  }
-  return true;
-}
-
-export function databasePropertyValuesForNewItem(
-  filters: DatabaseFilter[],
-  properties: DocumentProperty[],
-  filterMode: DatabaseFilterMode = "and",
-): Record<string, DocumentPropertyValue> {
-  const propertyValues: Record<string, DocumentPropertyValue> = {};
-  const activeFilters = filters.filter(isActiveFilter);
-  if (filterMode === "or" && activeFilters.length > 1) {
-    return propertyValues;
-  }
-
-  for (const filter of activeFilters) {
-    if (filter.key === "name") continue;
-
-    const property = properties.find(
-      (candidate) => candidate.definition.id === filter.key,
-    );
-    if (!property?.editable) continue;
-    if (isComputedPropertyType(property.definition.type)) continue;
-    if (propertyValues[property.definition.id] !== undefined) continue;
-
-    const value = databaseFilterDefaultValueForNewItem(filter, property);
-    if (value !== undefined) {
-      propertyValues[property.definition.id] = value;
-    }
-  }
-
-  return propertyValues;
-}
-
-function databaseFilterDefaultValueForNewItem(
-  filter: DatabaseFilter,
-  property: DocumentProperty,
-): DocumentPropertyValue | undefined {
-  if (filter.operator === "is_checked") {
-    return property.definition.type === "checkbox" ? true : undefined;
-  }
-  if (filter.operator === "is_unchecked") {
-    return property.definition.type === "checkbox" ? false : undefined;
-  }
-  if (property.definition.type === "multi_select") {
-    if (filter.operator !== "equals" && filter.operator !== "contains") {
-      return undefined;
-    }
-    const values = databaseFilterSelectedValues(filter.value);
-    if (values.length === 0) return undefined;
-    return values.map(
-      (value) =>
-        databasePropertyOptionIdForFilterValue(property, value) ?? value,
-    );
-  }
-  if (property.definition.type === "person" && filter.operator === "contains") {
-    const values = databaseFilterSelectedValues(filter.value);
-    return values.length > 0 ? values : undefined;
-  }
-  if (filter.operator !== "equals") return undefined;
-
-  const value = filter.value.trim();
-  if (!value) return undefined;
-
-  const optionValue = databasePropertyOptionIdForFilterValue(property, value);
-  if (
-    property.definition.type === "select" ||
-    property.definition.type === "status"
-  ) {
-    return optionValue ?? value;
-  }
-  if (property.definition.type === "date") {
-    return /^\d{4}-\d{2}-\d{2}$/.test(value)
-      ? { start: value, includeTime: false }
-      : undefined;
-  }
-  if (property.definition.type === "checkbox") return undefined;
-
-  return value;
-}
-
-function databasePropertyOptionIdForFilterValue(
-  property: DocumentProperty,
-  value: string,
-) {
-  return property.definition.options.options?.find(
-    (option) =>
-      option.id === value ||
-      option.name.trim().toLowerCase() === value.trim().toLowerCase(),
-  )?.id;
-}
-
-function databaseFilterSelectedValues(value: string) {
-  const trimmed = value.trim();
-  if (!trimmed) return [];
-  try {
-    const parsed = JSON.parse(trimmed) as unknown;
-    if (!Array.isArray(parsed)) return [trimmed];
-    return [
-      ...new Set(
-        parsed
-          .filter((item): item is string => typeof item === "string")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      ),
-    ];
-  } catch {
-    return [trimmed];
-  }
-}
-
-function databaseFilterDateRangeValues(value: string): [string, string] {
-  const trimmed = value.trim();
-  if (!trimmed) return ["", ""];
-  try {
-    const parsed = JSON.parse(trimmed) as unknown;
-    if (!Array.isArray(parsed)) return [trimmed, ""];
-    const start = typeof parsed[0] === "string" ? parsed[0].trim() : "";
-    const end = typeof parsed[1] === "string" ? parsed[1].trim() : "";
-    return [start, end];
-  } catch {
-    return [trimmed, ""];
-  }
-}
-
-function databaseFilterDateRangeValue(value: string): [number, number] | null {
-  const [startValue, endValue] = databaseFilterDateRangeValues(value);
-  const start = new Date(startValue).getTime();
-  const end = new Date(endValue).getTime();
-  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
-  return start <= end ? [start, end] : [end, start];
-}
-
-function databaseItemMatchesFilter(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  filter: DatabaseFilter,
-) {
-  const value = databaseItemFilterValue(item, properties, filter.key);
-  const property = databaseItemFilterProperty(item, properties, filter.key);
-
-  if (filter.operator === "is_empty") return !value.trim();
-  if (filter.operator === "is_not_empty") return !!value.trim();
-
-  if (filter.operator === "is_checked") return property?.value === true;
-  if (filter.operator === "is_unchecked") return property?.value !== true;
-
-  if (filter.operator === "greater_than" || filter.operator === "less_than") {
-    const current = propertyNumberValue(property);
-    const target = Number(filter.value.trim());
-    if (!Number.isFinite(current) || !Number.isFinite(target)) return false;
-    return filter.operator === "greater_than"
-      ? current > target
-      : current < target;
-  }
-
-  if (
-    filter.operator === "before" ||
-    filter.operator === "after" ||
-    filter.operator === "between"
-  ) {
-    const current = propertyDateValue(property);
-    if (!Number.isFinite(current)) return false;
-    if (filter.operator === "between") {
-      const range = databaseFilterDateRangeValue(filter.value);
-      if (!range) return false;
-      return current >= range[0] && current <= range[1];
-    }
-    const target = new Date(filter.value.trim()).getTime();
-    if (!Number.isFinite(target)) return false;
-    return filter.operator === "before" ? current < target : current > target;
-  }
-
-  const candidateValues = databaseItemFilterCandidateValues(
-    item,
-    properties,
-    filter.key,
-  ).map((candidate) => candidate.trim().toLowerCase());
-  const selectedFilterValues = databaseFilterSelectedValues(filter.value).map(
-    (candidate) => candidate.trim().toLowerCase(),
-  );
-  const normalizedValue = value.trim().toLowerCase();
-  const normalizedFilter = selectedFilterValues[0] ?? "";
-  const usesDiscreteValues =
-    property?.definition.type === "select" ||
-    property?.definition.type === "status" ||
-    property?.definition.type === "multi_select" ||
-    property?.definition.type === "person";
-
-  if (
-    usesDiscreteValues &&
-    (filter.operator === "equals" || filter.operator === "contains")
-  ) {
-    return selectedFilterValues.some((filterValue) =>
-      candidateValues.includes(filterValue),
-    );
-  }
-  if (usesDiscreteValues && filter.operator === "does_not_equal") {
-    return selectedFilterValues.every(
-      (filterValue) => !candidateValues.includes(filterValue),
-    );
-  }
-
-  if (filter.operator === "equals") {
-    return candidateValues.includes(normalizedFilter);
-  }
-  if (filter.operator === "does_not_equal") {
-    return !candidateValues.includes(normalizedFilter);
-  }
-  return normalizedValue.includes(normalizedFilter);
-}
-
-function databaseItemSearchText(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-) {
-  return [
-    item.document.title || "Untitled",
-    ...properties.map((property) =>
-      propertyValueText(
-        item.properties.find(
-          (candidate) => candidate.definition.id === property.definition.id,
-        ) ?? property,
-      ),
-    ),
-  ].join(" ");
-}
-
-function databaseItemSortValue(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  key: string,
-) {
-  if (key === "name") return item.document.title || "";
-  const property = properties.find(
-    (candidate) => candidate.definition.id === key,
-  );
-  const itemProperty = item.properties.find(
-    (candidate) => candidate.definition.id === key,
-  );
-  return propertyValueText(itemProperty ?? property ?? null);
-}
-
-function databaseItemFilterValue(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  key: string,
-) {
-  if (key === "name") return item.document.title || "";
-  return propertyValueText(databaseItemFilterProperty(item, properties, key));
-}
-
-function databaseItemFilterProperty(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  key: string,
-) {
-  if (key === "name") return null;
-  const property = properties.find(
-    (candidate) => candidate.definition.id === key,
-  );
-  const itemProperty = item.properties.find(
-    (candidate) => candidate.definition.id === key,
-  );
-  return itemProperty ?? property ?? null;
-}
-
-function databaseItemFilterCandidateValues(
-  item: ContentDatabaseItem,
-  properties: DocumentProperty[],
-  key: string,
-) {
-  if (key === "name") return [item.document.title || ""];
-  const property = databaseItemFilterProperty(item, properties, key);
-  if (!property) return [""];
-  const value = property.value;
-
-  if (value === null || value === undefined || value === "") return [""];
-
-  if (Array.isArray(value)) {
-    return value.flatMap((id) => {
-      const optionName =
-        property.definition.options.options?.find((option) => option.id === id)
-          ?.name ?? id;
-      return [id, optionName];
-    });
-  }
-
-  if (
-    property.definition.type === "select" ||
-    property.definition.type === "status"
-  ) {
-    const id =
-      typeof value === "string" ? value : (JSON.stringify(value) ?? "");
-    const optionName =
-      property.definition.options.options?.find((option) => option.id === id)
-        ?.name ?? id;
-    return [id, optionName];
-  }
-
-  return [propertyValueText(property)];
-}
-
 export function propertyValueText(
   property: DocumentProperty | null | undefined,
 ) {
@@ -627,23 +134,6 @@ export function propertyValueText(
   return formulaValueText(value);
 }
 
-function compareDatabaseSortValues(left: string, right: string) {
-  const leftNumber = Number(left);
-  const rightNumber = Number(right);
-  if (
-    left.trim() &&
-    right.trim() &&
-    Number.isFinite(leftNumber) &&
-    Number.isFinite(rightNumber)
-  ) {
-    return leftNumber - rightNumber;
-  }
-  return left.localeCompare(right, undefined, {
-    numeric: true,
-    sensitivity: "base",
-  });
-}
-
 export function propertyNumberValue(
   property: DocumentProperty | null | undefined,
 ) {
@@ -666,268 +156,3 @@ export function propertyNumberValue(
         );
   return Number.isFinite(value) ? value : Number.NaN;
 }
-
-export function databaseFilterOptionChoices(
-  key: string,
-  properties: DocumentProperty[],
-  items: ContentDatabaseItem[] = [],
-) {
-  const property = databaseFilterPropertyForKey(key, properties);
-  if (property?.definition.type === "person") {
-    return databaseFilterPersonChoices(property.definition.id, items);
-  }
-  const optionProperty = databaseFilterOptionPropertyForKey(key, properties);
-  return optionProperty?.definition.options.options ?? [];
-}
-
-function databaseFilterPersonChoices(
-  propertyId: string,
-  items: ContentDatabaseItem[],
-) {
-  const people = new Map<string, string>();
-  for (const item of items) {
-    const property = item.properties.find(
-      (candidate) => candidate.definition.id === propertyId,
-    );
-    for (const person of databasePersonItems(property?.value ?? null)) {
-      const key = person.trim().toLowerCase();
-      if (!people.has(key)) people.set(key, person);
-    }
-  }
-  return Array.from(people.values()).map((person) => ({
-    id: person,
-    name: databasePersonLabel(person),
-    color: "gray" as const,
-  }));
-}
-
-function databasePersonItems(value: DocumentProperty["value"]) {
-  const rawItems = Array.isArray(value)
-    ? value
-    : typeof value === "string"
-      ? value.split(/[\n,]+/)
-      : [];
-  const seen = new Set<string>();
-  return rawItems
-    .map((item) => item.trim())
-    .filter((item) => {
-      if (!item) return false;
-      const key = item.toLowerCase();
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-}
-
-function databasePersonLabel(value: string) {
-  const trimmed = value.trim();
-  if (!trimmed) return "Empty";
-  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)
-    ? trimmed
-        .split("@")[0]
-        .split(/[._-]+/)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ")
-    : trimmed;
-}
-
-export function databaseFilterOptionPropertyForKey(
-  key: string,
-  properties: DocumentProperty[],
-) {
-  const property = databaseFilterPropertyForKey(key, properties);
-  if (!property) return null;
-  if (
-    property.definition.type !== "select" &&
-    property.definition.type !== "status" &&
-    property.definition.type !== "multi_select" &&
-    property.definition.type !== "person"
-  ) {
-    return null;
-  }
-  return property;
-}
-
-function databaseFilterValueLabel(
-  filter: DatabaseFilter,
-  properties: DocumentProperty[],
-) {
-  if (filter.operator === "between") {
-    const [start, end] = databaseFilterDateRangeValues(filter.value);
-    if (start && end) return `${start} to ${end}`;
-    return start || end || "Choose dates";
-  }
-  const option = databaseFilterOptionChoices(filter.key, properties).find(
-    (candidate) =>
-      candidate.id === filter.value || candidate.name === filter.value,
-  );
-  return (option?.name ?? filter.value) || "Choose option";
-}
-
-export { databaseFilterValueLabel };
-
-export function databaseFilterChipLabel(
-  filter: DatabaseFilter,
-  properties: DocumentProperty[],
-) {
-  const operator = FILTER_OPERATOR_LABELS[filter.operator] ?? "Contains";
-  if (!filterOperatorNeedsValue(filter.operator)) {
-    return `${filter.label} ${operator.toLowerCase()}`;
-  }
-  return `${filter.label} ${operator.toLowerCase()} ${databaseFilterValueLabel(
-    filter,
-    properties,
-  )}`;
-}
-
-function databaseFilterPropertyForKey(
-  key: string,
-  properties: DocumentProperty[],
-) {
-  if (key === "name") return null;
-  return properties.find((property) => property.definition.id === key) ?? null;
-}
-
-export const FILTER_OPERATOR_LABELS: Record<FilterOperator, string> = {
-  contains: "Contains",
-  equals: "Is",
-  does_not_equal: "Is not",
-  greater_than: "Greater than",
-  less_than: "Less than",
-  before: "Before",
-  after: "After",
-  between: "Between",
-  is_checked: "Checked",
-  is_unchecked: "Unchecked",
-  is_empty: "Is empty",
-  is_not_empty: "Is not empty",
-};
-
-export function filterOperatorsForKey(
-  key: string,
-  properties: DocumentProperty[],
-): FilterOperator[] {
-  const type = filterPropertyTypeForKey(key, properties);
-
-  if (type === "checkbox") {
-    return ["is_checked", "is_unchecked"];
-  }
-
-  if (
-    type === "select" ||
-    type === "status" ||
-    type === "multi_select" ||
-    type === "person"
-  ) {
-    return ["contains", "does_not_equal", "is_empty", "is_not_empty"];
-  }
-
-  if (type === "number") {
-    return [
-      "equals",
-      "does_not_equal",
-      "greater_than",
-      "less_than",
-      "is_empty",
-      "is_not_empty",
-    ];
-  }
-
-  if (
-    type === "date" ||
-    type === "created_time" ||
-    type === "last_edited_time"
-  ) {
-    return [
-      "equals",
-      "does_not_equal",
-      "before",
-      "after",
-      "between",
-      "is_empty",
-      "is_not_empty",
-    ];
-  }
-
-  return ["contains", "equals", "does_not_equal", "is_empty", "is_not_empty"];
-}
-
-export function defaultFilterOperatorForKey(
-  key: string,
-  properties: DocumentProperty[],
-): FilterOperator {
-  return filterOperatorsForKey(key, properties)[0] ?? "contains";
-}
-
-export function filterPropertyTypeForKey(
-  key: string,
-  properties: DocumentProperty[],
-): DocumentPropertyType {
-  if (key === "name") return "text";
-  return (
-    properties.find((property) => property.definition.id === key)?.definition
-      .type ?? "text"
-  );
-}
-
-export function filterOperatorNeedsValue(operator: FilterOperator) {
-  return !["is_empty", "is_not_empty", "is_checked", "is_unchecked"].includes(
-    operator,
-  );
-}
-
-export function filterValuePlaceholder(
-  key: string,
-  properties: DocumentProperty[],
-) {
-  const type = filterPropertyTypeForKey(key, properties);
-  if (type === "number") return "Number";
-  if (type === "person") return "Person or email";
-  if (type === "place") return "City, venue, or address";
-  if (type === "files_media") return "File or media link";
-  if (type === "date" || type === "created_time" || type === "last_edited_time")
-    return "YYYY-MM-DD";
-  return "Value";
-}
-
-export function filterValueInputType(type: DocumentPropertyType) {
-  if (type === "number") return "number";
-  if (type === "date" || type === "created_time" || type === "last_edited_time")
-    return "date";
-  return "text";
-}
-
-export function databaseTableRowDensityClass(rowDensity: DatabaseRowDensity) {
-  if (rowDensity === "compact") return "min-h-8";
-  if (rowDensity === "comfortable") return "min-h-12";
-  return "min-h-9";
-}
-
-export function databaseTableCellDensityClass(rowDensity: DatabaseRowDensity) {
-  if (rowDensity === "compact") return "px-2 py-0.5";
-  if (rowDensity === "comfortable") return "px-2.5 py-2";
-  return "px-2 py-1";
-}
-
-export function databaseRowNameCellDensityClass(
-  rowDensity: DatabaseRowDensity,
-) {
-  if (rowDensity === "compact") return "px-1 py-0.5";
-  if (rowDensity === "comfortable") return "px-1.5 py-2";
-  return "px-1 py-1";
-}
-
-export function databaseTitleButtonDensityClass(
-  rowDensity: DatabaseRowDensity,
-  wrapCells: boolean,
-) {
-  if (wrapCells) {
-    if (rowDensity === "compact") return "min-h-6 py-0.5";
-    if (rowDensity === "comfortable") return "min-h-9 py-1.5";
-    return "min-h-7 py-1";
-  }
-  if (rowDensity === "compact") return "h-6";
-  if (rowDensity === "comfortable") return "h-8";
-  return "h-7";
-}