tsense 0.2.0-next.5 → 0.2.0-next.7

package/dist/filters/filter-state.d.ts

@@ -1,5 +1,6 @@
+import type { RelativeDate } from "../types.js";
 import type { FilterDescriptor } from "./index.js";
-export type FilterValue = string | string[] | number | boolean | Date | [FilterValue | undefined, FilterValue | undefined] | undefined;
+export type FilterValue = string | string[] | number | boolean | Date | RelativeDate | [FilterValue | undefined, FilterValue | undefined] | undefined;
 export type FilterRow = {
     id: number;
     field?: string;
@@ -8,6 +9,7 @@ export type FilterRow = {
 };
 export type FilterState = {
     rows: FilterRow[];
+    manualRowIds: Set<number>;
 };
 export declare function createInitialState(): FilterState;
 export declare function addRow(state: FilterState): FilterState;
@@ -16,8 +18,9 @@ export declare function removeRow(state: FilterState, index: number): FilterStat
 export declare function setRowField(state: FilterState, index: number, field: string): FilterState;
 export declare function setRowCondition(state: FilterState, index: number, condition: string): FilterState;
 export declare function setRowValue(state: FilterState, index: number, value: FilterValue): FilterState;
+export declare function restoreRows(rows: Omit<FilterRow, "id">[]): FilterState;
 export declare function clearState(): FilterState;
-export declare function applyPreset<T>(state: FilterState, descriptor: FilterDescriptor<T>, field: string, name: string): FilterState;
+export declare function hasManualRows(state: FilterState): boolean;
 export declare function conditionsFor<T>(descriptor: FilterDescriptor<T>, field: string): FilterDescriptor<T>["columns"][number]["conditions"];
 export declare function columnFor<T>(descriptor: FilterDescriptor<T>, field: string): FilterDescriptor<T>["columns"][number];
 export declare function buildResult(state: FilterState): Record<string, unknown>;

package/dist/filters/filter-state.js

@@ -11,94 +11,65 @@ const conditionToOperator = {
 };
 let nextRowId = 0;
 export function createInitialState() {
-    return { rows: [] };
+    return { rows: [], manualRowIds: new Set() };
 }
 export function addRow(state) {
-    return { rows: [...state.rows, { id: ++nextRowId }] };
+    const id = ++nextRowId;
+    return {
+        rows: [...state.rows, { id }],
+        manualRowIds: new Set([...state.manualRowIds, id]),
+    };
 }
 export function addRowWithField(state, field) {
-    return { rows: [...state.rows, { id: ++nextRowId, field }] };
+    const id = ++nextRowId;
+    return {
+        rows: [...state.rows, { id, field }],
+        manualRowIds: new Set([...state.manualRowIds, id]),
+    };
 }
 export function removeRow(state, index) {
-    return { rows: state.rows.filter((_, i) => i !== index) };
+    const removed = state.rows[index];
+    const manualRowIds = new Set(state.manualRowIds);
+    if (removed) {
+        manualRowIds.delete(removed.id);
+    }
+    return {
+        rows: state.rows.filter((_, i) => i !== index),
+        manualRowIds,
+    };
 }
 export function setRowField(state, index, field) {
     return {
         rows: state.rows.map((row, i) => i === index ? { id: row.id, field } : row),
+        manualRowIds: state.manualRowIds,
     };
 }
 export function setRowCondition(state, index, condition) {
     return {
         rows: state.rows.map((row, i) => i === index ? { ...row, condition, value: undefined } : row),
+        manualRowIds: state.manualRowIds,
     };
 }
 export function setRowValue(state, index, value) {
     return {
         rows: state.rows.map((row, i) => (i === index ? { ...row, value } : row)),
+        manualRowIds: state.manualRowIds,
     };
 }
-export function clearState() {
-    return { rows: [] };
-}
-function filterValueToRow(field, filterValue) {
-    if (filterValue == null) {
-        return null;
-    }
-    if (Array.isArray(filterValue)) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "is_in",
-            value: filterValue,
-        };
-    }
-    if (typeof filterValue !== "object" || filterValue instanceof Date) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "equals",
-            value: filterValue,
-        };
-    }
-    const operators = filterValue;
-    const keys = Object.keys(operators);
-    if (keys.includes("gte") && keys.includes("lte")) {
-        return {
-            id: ++nextRowId,
-            field,
-            condition: "between",
-            value: [operators.gte, operators.lte],
-        };
-    }
-    if (!keys[0]) {
-        return null;
-    }
+export function restoreRows(rows) {
     return {
-        id: ++nextRowId,
-        field,
-        condition: keys[0],
-        value: operators[keys[0]],
+        rows: rows.map((row) => ({ ...row, id: ++nextRowId })),
+        manualRowIds: new Set(),
     };
 }
-export function applyPreset(state, descriptor, field, name) {
-    const column = descriptor.columns.find((c) => c.key === field);
-    const preset = column?.presets?.find((p) => p.name === name);
-    if (!preset) {
-        return state;
-    }
-    const presetRows = [];
-    for (const [key, value] of Object.entries(preset.filter)) {
-        const row = filterValueToRow(key, value);
-        if (row) {
-            presetRows.push(row);
-        }
-    }
-    if (!presetRows.length) {
-        return state;
-    }
-    const presetFields = new Set(presetRows.map((r) => r.field));
-    const preserved = state.rows.filter((r) => !r.field || !presetFields.has(r.field));
-    return { rows: [...preserved, ...presetRows] };
+export function clearState() {
+    return { rows: [], manualRowIds: new Set() };
+}
+export function hasManualRows(state) {
+    return state.rows.some((r) => state.manualRowIds.has(r.id) &&
+        r.field != null &&
+        r.condition != null &&
+        r.value != null);
 }
 export function conditionsFor(descriptor, field) {
     const column = descriptor.columns.find((c) => c.key === field);

package/dist/filters/index.d.ts

@@ -1,14 +1,14 @@
-export { isRelativeDate, resolveRelativeDate } from './relative-dates.js';
-export { deserializeFilter, serializeFilter } from './url.js';
-import type { Type } from 'arktype';
-import type { TSense } from '../tsense.js';
-import type { FilterFor, SearchInput } from '../types.js';
+export { isRelativeDate, resolveRelativeDate } from "./relative-dates.js";
+export { deserializeFilter, serializeFilter } from "./url.js";
+import type { Type } from "arktype";
+import type { TSense } from "../tsense.js";
+import type { FilterFor, SearchInput } from "../types.js";
 export type FilterDescriptor<T = Record<string, unknown>> = {
     infer: FilterFor<T>;
     columns: {
         key: keyof T & string;
         label: string;
-        type: 'string' | 'number' | 'boolean' | 'date';
+        type: "string" | "number" | "boolean" | "date";
         conditions: {
             key: string;
             label: string;
@@ -17,25 +17,20 @@ export type FilterDescriptor<T = Record<string, unknown>> = {
             value: string;
             label: string;
         }[];
-        presets?: {
-            name: string;
-            filter: Record<string, unknown>;
-        }[];
     }[];
 };
-type FilterBuilderFieldConfig<T> = {
+type FilterBuilderFieldConfig = {
     label: string;
     labels?: Record<string, string>;
-    presets?: Record<string, FilterFor<T> | (() => FilterFor<T>)>;
 };
 type FilterBuilderReturn<T> = {
     describe(): FilterDescriptor<T>;
     schema(): Type<SearchInput<T>>;
 };
-type ColumnType = FilterDescriptor['columns'][number]['type'];
+type ColumnType = FilterDescriptor["columns"][number]["type"];
 type FilterBuilderOptions = {
-    conditionLabels?: Partial<Record<ColumnType | 'enum', Partial<Record<string, string>>>>;
+    conditionLabels?: Partial<Record<ColumnType | "enum", Partial<Record<string, string>>>>;
 };
 export declare function createFilterBuilder<T extends Type>(collection: TSense<T>, config: {
-    [K in keyof T['infer']]?: FilterBuilderFieldConfig<T['infer']>;
-}, options?: FilterBuilderOptions): FilterBuilderReturn<T['infer']>;
+    [K in keyof T["infer"]]?: FilterBuilderFieldConfig;
+}, options?: FilterBuilderOptions): FilterBuilderReturn<T["infer"]>;

package/dist/filters/index.js

@@ -1,46 +1,46 @@
-export { isRelativeDate, resolveRelativeDate } from './relative-dates.js';
-export { deserializeFilter, serializeFilter } from './url.js';
-import { type } from 'arktype';
+export { isRelativeDate, resolveRelativeDate } from "./relative-dates.js";
+export { deserializeFilter, serializeFilter } from "./url.js";
+import { type } from "arktype";
 const tsenseTypeMap = {
-    string: 'string',
-    'string*': 'string',
-    'string[]': 'string',
-    int32: 'number',
-    int64: 'number',
-    float: 'number',
-    'int32[]': 'number',
-    'int64[]': 'number',
-    'float[]': 'number',
-    bool: 'boolean',
-    'bool[]': 'boolean',
-    auto: 'string',
-    image: 'string',
+    string: "string",
+    "string*": "string",
+    "string[]": "string",
+    int32: "number",
+    int64: "number",
+    float: "number",
+    "int32[]": "number",
+    "int64[]": "number",
+    "float[]": "number",
+    bool: "boolean",
+    "bool[]": "boolean",
+    auto: "string",
+    image: "string",
 };
 const enumConditions = [
-    { key: 'is_in', label: 'is in' },
-    { key: 'is_not_in', label: 'is not in' },
+    { key: "is_in", label: "is in" },
+    { key: "is_not_in", label: "is not in" },
 ];
 const conditionsByType = {
     string: [
-        { key: 'equals', label: 'equals' },
-        { key: 'not_equals', label: 'not equals' },
+        { key: "equals", label: "equals" },
+        { key: "not_equals", label: "not equals" },
     ],
     number: [
-        { key: 'equals', label: 'equals' },
-        { key: 'not_equals', label: 'not equals' },
-        { key: 'gt', label: 'greater than' },
-        { key: 'gte', label: 'greater than or equal' },
-        { key: 'lt', label: 'less than' },
-        { key: 'lte', label: 'less than or equal' },
-        { key: 'between', label: 'between' },
+        { key: "equals", label: "equals" },
+        { key: "not_equals", label: "not equals" },
+        { key: "gt", label: "greater than" },
+        { key: "gte", label: "greater than or equal" },
+        { key: "lt", label: "less than" },
+        { key: "lte", label: "less than or equal" },
+        { key: "between", label: "between" },
     ],
-    boolean: [{ key: 'equals', label: 'equals' }],
+    boolean: [{ key: "equals", label: "equals" }],
     date: [
-        { key: 'equals', label: 'equals' },
-        { key: 'not_equals', label: 'not equals' },
-        { key: 'gt', label: 'after' },
-        { key: 'lt', label: 'before' },
-        { key: 'between', label: 'between' },
+        { key: "equals", label: "equals" },
+        { key: "not_equals", label: "not equals" },
+        { key: "gt", label: "after" },
+        { key: "lt", label: "before" },
+        { key: "between", label: "between" },
     ],
 };
 export function createFilterBuilder(collection, config, options) {
@@ -48,36 +48,36 @@ export function createFilterBuilder(collection, config, options) {
     return {
         schema() {
             const numberOps = type.raw({
-                'not?': 'number',
-                'gt?': 'number',
-                'gte?': 'number',
-                'lt?': 'number',
-                'lte?': 'number',
-                'notIn?': 'number[]',
+                "not?": "number",
+                "gt?": "number",
+                "gte?": "number",
+                "lt?": "number",
+                "lte?": "number",
+                "notIn?": "number[]",
             });
             const stringOps = type.raw({
-                'not?': 'string',
-                'notIn?': 'string[]',
+                "not?": "string",
+                "notIn?": "string[]",
             });
             const relativeDateUnit = "'day' | 'week' | 'month'";
             const relativeDate = type
                 .raw({ startOf: relativeDateUnit })
                 .or(type.raw({ endOf: relativeDateUnit }));
-            const concreteDateInput = type.raw('number | string | Date');
+            const concreteDateInput = type.raw("number | string | Date");
             const dateInput = concreteDateInput.or(relativeDate);
             const dateArrayInput = dateInput.array();
             const dateOps = type.raw({
-                'not?': dateInput,
-                'gt?': dateInput,
-                'gte?': dateInput,
-                'lt?': dateInput,
-                'lte?': dateInput,
-                'notIn?': dateArrayInput,
+                "not?": dateInput,
+                "gt?": dateInput,
+                "gte?": dateInput,
+                "lt?": dateInput,
+                "lte?": dateInput,
+                "notIn?": dateArrayInput,
             });
             const fieldSchemas = {
-                number: type.raw('number').or(type.raw('number[]')).or(numberOps),
-                string: type.raw('string').or(type.raw('string[]')).or(stringOps),
-                boolean: type.raw('boolean'),
+                number: type.raw("number").or(type.raw("number[]")).or(numberOps),
+                string: type.raw("string").or(type.raw("string[]")).or(stringOps),
+                boolean: type.raw("boolean"),
                 date: dateInput.or(dateArrayInput).or(dateOps),
             };
             const descriptor = this.describe();
@@ -87,10 +87,10 @@ export function createFilterBuilder(collection, config, options) {
             }
             return type
                 .raw({
-                'query?': 'string',
-                'filter?': type.raw(filterDef),
-                'page?': 'number',
-                'limit?': 'number',
+                "query?": "string",
+                "filter?": type.raw(filterDef),
+                "page?": "number",
+                "limit?": "number",
             })
                 .as();
         },
@@ -110,8 +110,8 @@ export function createFilterBuilder(collection, config, options) {
                 const fieldConfig = config[field.name];
                 if (!fieldConfig)
                     continue;
-                const columnType = field.sourceExpression === 'Date'
-                    ? 'date'
+                const columnType = field.sourceExpression === "Date"
+                    ? "date"
                     : tsenseTypeMap[field.type];
                 if (!columnType)
                     continue;
@@ -126,15 +126,7 @@ export function createFilterBuilder(collection, config, options) {
                         value: v,
                         label: fieldConfig.labels?.[v] ?? v,
                     }));
-                    column.conditions = withLabels(enumConditions, 'enum');
-                }
-                if (fieldConfig.presets) {
-                    column.presets = Object.entries(fieldConfig.presets).map(([name, filterOrFn]) => ({
-                        name,
-                        filter: (typeof filterOrFn === 'function'
-                            ? filterOrFn()
-                            : filterOrFn),
-                    }));
+                    column.conditions = withLabels(enumConditions, "enum");
                 }
                 columns.push(column);
             }

package/dist/filters/relative-dates.d.ts

@@ -1,3 +1,3 @@
-import type { RelativeDate } from '../types.js';
+import type { RelativeDate } from "../types.js";
 export declare function isRelativeDate(value: unknown): value is RelativeDate;
 export declare function resolveRelativeDate(expr: RelativeDate, tz: string, now?: Date): Date;

package/dist/filters/relative-dates.js

@@ -1,19 +1,19 @@
-import dayjs from 'dayjs';
-import timezone from 'dayjs/plugin/timezone.js';
-import utc from 'dayjs/plugin/utc.js';
+import dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
 dayjs.extend(utc);
 dayjs.extend(timezone);
 export function isRelativeDate(value) {
-    if (typeof value !== 'object' || value === null || value instanceof Date) {
+    if (typeof value !== "object" || value === null || value instanceof Date) {
         return false;
     }
     const obj = value;
-    return (('startOf' in obj && typeof obj.startOf === 'string') ||
-        ('endOf' in obj && typeof obj.endOf === 'string'));
+    return (("startOf" in obj && typeof obj.startOf === "string") ||
+        ("endOf" in obj && typeof obj.endOf === "string"));
 }
 export function resolveRelativeDate(expr, tz, now) {
     const base = now ? dayjs(now).tz(tz) : dayjs().tz(tz);
-    if ('startOf' in expr) {
+    if ("startOf" in expr) {
         return base.startOf(expr.startOf).toDate();
     }
     return base.endOf(expr.endOf).toDate();

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export type { TsenseFieldMeta, TsenseFieldType } from './env.js';
-export { rank } from './rank.js';
-export { DateTransformer } from './transformers/date.js';
-export { defaultTransformers } from './transformers/defaults.js';
-export type { FieldTransformer } from './transformers/types.js';
-export { TSense } from './tsense.js';
-export { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';
-export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, RelativeDate, RelativeDateUnit, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from './types.js';
+export type { TsenseFieldMeta, TsenseFieldType } from "./env.js";
+export { rank } from "./rank.js";
+export { DateTransformer } from "./transformers/date.js";
+export { defaultTransformers } from "./transformers/defaults.js";
+export type { FieldTransformer } from "./transformers/types.js";
+export { TSense } from "./tsense.js";
+export { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";
+export type { ConnectionConfig, DeleteResult, FilterFor, HighlightOptions, NumberFilter, ProjectSearch, RelativeDate, RelativeDateUnit, SearchListOptions, SearchListResult, SearchInput, SearchOptions, ScopedCollection, SearchOptionsPlain, SearchOptionsWithOmit, SearchOptionsWithPick, SearchResult, StringFilter, SyncConfig, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult, } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { rank } from './rank.js';
-export { DateTransformer } from './transformers/date.js';
-export { defaultTransformers } from './transformers/defaults.js';
-export { TSense } from './tsense.js';
-export { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';
+export { rank } from "./rank.js";
+export { DateTransformer } from "./transformers/date.js";
+export { defaultTransformers } from "./transformers/defaults.js";
+export { TSense } from "./tsense.js";
+export { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";

package/dist/react/filter-builder/filter-builder-defaults.d.ts

@@ -1,7 +1,6 @@
-import type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, PresetButtonSlotProps, RemoveButtonSlotProps, ValueInputSlotProps } from "./filter-builder-types.js";
+import type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, RemoveButtonSlotProps, ValueInputSlotProps } from "./filter-builder-types.js";
 export declare function defaultFieldSelect({ columns, value, onChange }: FieldSelectSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultConditionSelect({ conditions, value, onChange, disabled }: ConditionSelectSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultValueInput({ column, condition, value, onChange }: ValueInputSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultRemoveButton({ onClick }: RemoveButtonSlotProps): import("react/jsx-runtime").JSX.Element;
 export declare function defaultAddButton({ onClick }: AddButtonSlotProps): import("react/jsx-runtime").JSX.Element;
-export declare function defaultPresetButton({ preset, onClick }: PresetButtonSlotProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/filter-builder/filter-builder-defaults.js

@@ -81,6 +81,3 @@ export function defaultRemoveButton({ onClick }) {
 export function defaultAddButton({ onClick }) {
     return (_jsx("button", { type: "button", className: "text-blue-500 hover:text-blue-700", onClick: onClick, children: "+ Add filter" }));
 }
-export function defaultPresetButton({ preset, onClick, }) {
-    return (_jsx("button", { type: "button", className: "rounded bg-gray-100 px-2 py-1 text-sm hover:bg-gray-200", onClick: onClick, children: preset.name }));
-}

package/dist/react/filter-builder/filter-builder-types.d.ts

@@ -25,13 +25,6 @@ export type RemoveButtonSlotProps = {
 export type AddButtonSlotProps = {
     onClick: () => void;
 };
-export type PresetButtonSlotProps = {
-    preset: {
-        field: string;
-        name: string;
-    };
-    onClick: () => void;
-};
 export type RowSlotProps = {
     index: number;
     fieldSelect: ReactNode;
@@ -42,7 +35,6 @@ export type RowSlotProps = {
 export type RootSlotProps = {
     rows: ReactNode;
     addButton: ReactNode;
-    presets: ReactNode | null;
 };
 export type FilterBuilderProps<T> = {
     descriptor: FilterDescriptor<T>;
@@ -54,5 +46,4 @@ export type FilterBuilderProps<T> = {
     renderValueInput?: (props: ValueInputSlotProps) => ReactNode;
     renderAddButton?: (props: AddButtonSlotProps) => ReactNode;
     renderRemoveButton?: (props: RemoveButtonSlotProps) => ReactNode;
-    renderPresetButton?: (props: PresetButtonSlotProps) => ReactNode;
 };

package/dist/react/filter-builder/filter-builder.d.ts

@@ -1,3 +1,3 @@
 import { type ReactNode } from "react";
 import type { FilterBuilderProps } from "./filter-builder-types.js";
-export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton }: FilterBuilderProps<T>): ReactNode;
+export declare function FilterBuilder<T>({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton }: FilterBuilderProps<T>): ReactNode;

package/dist/react/filter-builder/filter-builder.js

@@ -1,8 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment, useEffect, useRef } from "react";
 import { useFilterBuilder } from "../use-filter-builder.js";
-import { defaultAddButton, defaultConditionSelect, defaultFieldSelect, defaultPresetButton, defaultRemoveButton, defaultValueInput, } from "./filter-builder-defaults.js";
-export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, renderPresetButton, }) {
+import { defaultAddButton, defaultConditionSelect, defaultFieldSelect, defaultRemoveButton, defaultValueInput, } from "./filter-builder-defaults.js";
+export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, renderFieldSelect, renderConditionSelect, renderValueInput, renderAddButton, renderRemoveButton, }) {
     const filters = useFilterBuilder(descriptor);
     const onChangeRef = useRef(onChange);
     onChangeRef.current = onChange;
@@ -14,7 +14,6 @@ export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, ren
     const ValueInput = renderValueInput ?? defaultValueInput;
     const RemoveButton = renderRemoveButton ?? defaultRemoveButton;
     const AddButton = renderAddButton ?? defaultAddButton;
-    const PresetButton = renderPresetButton ?? defaultPresetButton;
     const rows = filters.rows.map((row, index) => {
         const fieldSelect = (_jsx(FieldSelect, { columns: filters.columns, value: row.field, onChange: (field) => filters.setField(index, field) }));
         const conditionSelect = (_jsx(ConditionSelect, { conditions: row.field ? filters.conditionsFor(row.field) : [], value: row.condition, onChange: (condition) => filters.setCondition(index, condition), disabled: !row.field }));
@@ -32,9 +31,8 @@ export function FilterBuilder({ descriptor, onChange, renderRoot, renderRow, ren
         return (_jsxs("div", { className: "flex items-center gap-2", children: [fieldSelect, conditionSelect, valueInput, removeButton] }, row.id));
     });
     const addButton = _jsx(AddButton, { onClick: filters.add });
-    const presets = filters.presets.length > 0 ? (_jsx("div", { className: "flex flex-wrap gap-1 border-t pt-2", children: filters.presets.map((preset) => (_jsx(Fragment, { children: _jsx(PresetButton, { preset: preset, onClick: () => filters.applyPreset(preset.field, preset.name) }) }, `${preset.field}-${preset.name}`))) })) : null;
     if (renderRoot) {
-        return _jsx(_Fragment, { children: renderRoot({ rows: _jsx(_Fragment, { children: rows }), addButton, presets }) });
+        return _jsx(_Fragment, { children: renderRoot({ rows: _jsx(_Fragment, { children: rows }), addButton }) });
     }
-    return (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton, presets] }));
+    return (_jsxs("div", { className: "flex flex-col gap-2", children: [rows, addButton] }));
 }

package/dist/react/index.d.ts

@@ -1,4 +1,4 @@
 export { FilterBuilder } from "./filter-builder/filter-builder.js";
-export type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, PresetButtonSlotProps, RemoveButtonSlotProps, RootSlotProps, RowSlotProps, ValueInputSlotProps, } from "./filter-builder/filter-builder-types.js";
+export type { AddButtonSlotProps, ConditionSelectSlotProps, FieldSelectSlotProps, RemoveButtonSlotProps, RootSlotProps, RowSlotProps, ValueInputSlotProps, } from "./filter-builder/filter-builder-types.js";
 export type { FilterValue } from "../filters/filter-state.js";
 export { useFilterBuilder } from "./use-filter-builder.js";

package/dist/react/use-filter-builder.d.ts

@@ -1,12 +1,9 @@
 import { type FilterRow, type FilterValue } from "../filters/filter-state.js";
 import type { FilterDescriptor } from "../filters/index.js";
-type Preset = {
-    field: string;
-    name: string;
-};
 type UseFilterBuilderReturn = {
     columns: FilterDescriptor["columns"];
     rows: FilterRow[];
+    hasManualRows: boolean;
     add: () => void;
     addWithField: (field: string) => void;
     remove: (index: number) => void;
@@ -14,10 +11,9 @@ type UseFilterBuilderReturn = {
     setCondition: (index: number, condition: string) => void;
     setValue: (index: number, value: FilterValue) => void;
     clear: () => void;
+    restore: (rows: Omit<FilterRow, "id">[]) => void;
     conditionsFor: (field: string) => FilterDescriptor["columns"][number]["conditions"];
     columnFor: (field: string) => FilterDescriptor["columns"][number];
-    presets: Preset[];
-    applyPreset: (field: string, name: string) => void;
     result: Record<string, unknown>;
 };
 export declare function useFilterBuilder<T>(descriptor: FilterDescriptor<T>): UseFilterBuilderReturn;

package/dist/react/use-filter-builder.js

@@ -1,12 +1,12 @@
 import { useMemo, useState } from "react";
-import { addRow, addRowWithField, applyPreset as applyPresetState, buildResult, clearState, columnFor, conditionsFor, createInitialState, removeRow, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
+import { addRow, addRowWithField, buildResult, clearState, columnFor, conditionsFor, createInitialState, hasManualRows as hasManualRowsState, removeRow, restoreRows, setRowCondition, setRowField, setRowValue, } from "../filters/filter-state.js";
 export function useFilterBuilder(descriptor) {
     const [state, setState] = useState(createInitialState);
-    const presets = useMemo(() => descriptor.columns.flatMap((col) => (col.presets ?? []).map((p) => ({ field: col.key, name: p.name }))), [descriptor]);
     const result = useMemo(() => buildResult(state), [state]);
     return {
         columns: descriptor.columns,
         rows: state.rows,
+        hasManualRows: hasManualRowsState(state),
         add: () => setState(addRow),
         addWithField: (field) => setState((s) => addRowWithField(s, field)),
         remove: (index) => setState((s) => removeRow(s, index)),
@@ -14,10 +14,9 @@ export function useFilterBuilder(descriptor) {
         setCondition: (index, condition) => setState((s) => setRowCondition(s, index, condition)),
         setValue: (index, value) => setState((s) => setRowValue(s, index, value)),
         clear: () => setState(clearState),
+        restore: (rows) => setState(() => restoreRows(rows)),
         conditionsFor: (field) => conditionsFor(descriptor, field),
         columnFor: (field) => columnFor(descriptor, field),
-        presets,
-        applyPreset: (field, name) => setState((s) => applyPresetState(s, descriptor, field, name)),
         result,
     };
 }

package/dist/tsense.d.ts

@@ -1,6 +1,6 @@
-import type { Type } from 'arktype';
-import redaxios from 'redaxios';
-import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult } from './types.js';
+import type { Type } from "arktype";
+import redaxios from "redaxios";
+import type { DeleteResult, FieldSchema, FilterFor, ProjectSearch, ScopedCollection, SearchListOptions, SearchListResult, SearchOptions, SearchOptionsPlain, SearchResult, SyncOptions, SyncResult, TsenseOptions, UpdateResult, UpsertResult } from "./types.js";
 declare const redaxiosInstance: {
     <T>(urlOrConfig: string | redaxios.Options, config?: redaxios.Options | undefined, _method?: any, data?: any, _undefined?: undefined): Promise<redaxios.Response<T>>;
     request: (<T_1 = any>(config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_1>>) | (<T_2 = any>(url: string, config?: redaxios.Options | undefined) => Promise<redaxios.Response<T_2>>);
@@ -64,7 +64,7 @@ export declare class TSense<T extends Type> {
     private synced;
     private fieldTransformers;
     private dataSyncConfig?;
-    infer: T['infer'];
+    infer: T["infer"];
     constructor(options: TsenseOptions<T>);
     private getBaseType;
     private inferType;
@@ -85,23 +85,23 @@ export declare class TSense<T extends Type> {
     private buildSort;
     create(): Promise<this>;
     drop(): Promise<void>;
-    get(id: string): Promise<T['infer'] | null>;
+    get(id: string): Promise<T["infer"] | null>;
     delete(id: string): Promise<boolean>;
     private deleteManyWithFilterBy;
-    deleteMany(filter: FilterFor<T['infer']>): Promise<DeleteResult>;
-    update(id: string, data: Partial<T['infer']>): Promise<T['infer']>;
+    deleteMany(filter: FilterFor<T["infer"]>): Promise<DeleteResult>;
+    update(id: string, data: Partial<T["infer"]>): Promise<T["infer"]>;
     private updateManyWithFilterBy;
-    updateMany(filter: FilterFor<T['infer']>, data: Partial<T['infer']>): Promise<UpdateResult>;
+    updateMany(filter: FilterFor<T["infer"]>, data: Partial<T["infer"]>): Promise<UpdateResult>;
     private searchWithFilterBy;
-    search<const O extends SearchOptions<T['infer']> = SearchOptionsPlain<T['infer']>>(options: O): Promise<SearchResult<ProjectSearch<T['infer'], O>>>;
+    search<const O extends SearchOptions<T["infer"]> = SearchOptionsPlain<T["infer"]>>(options: O): Promise<SearchResult<ProjectSearch<T["infer"], O>>>;
     private searchListWithFilterBy;
-    searchList(options: SearchListOptions<T['infer']>): Promise<SearchListResult<T['infer']>>;
+    searchList(options: SearchListOptions<T["infer"]>): Promise<SearchListResult<T["infer"]>>;
     private countWithFilterBy;
-    count(filter?: FilterFor<T['infer']>): Promise<number>;
-    upsert(docs: T['infer'] | T['infer'][]): Promise<UpsertResult[]>;
+    count(filter?: FilterFor<T["infer"]>): Promise<number>;
+    upsert(docs: T["infer"] | T["infer"][]): Promise<UpsertResult[]>;
     syncData(options?: SyncOptions): Promise<SyncResult>;
     private purgeOrphans;
     exportIds(): Promise<string[]>;
-    scoped(baseFilter: FilterFor<T['infer']>): ScopedCollection<T['infer']>;
+    scoped(baseFilter: FilterFor<T["infer"]>): ScopedCollection<T["infer"]>;
 }
 export {};

package/dist/tsense.js

@@ -1,7 +1,7 @@
-import redaxios from 'redaxios';
-import { isRelativeDate, resolveRelativeDate, } from './filters/relative-dates.js';
-import { TSenseMigrator } from './migrator.js';
-import { defaultTransformers } from './transformers/defaults.js';
+import redaxios from "redaxios";
+import { isRelativeDate, resolveRelativeDate, } from "./filters/relative-dates.js";
+import { TSenseMigrator } from "./migrator.js";
+import { defaultTransformers } from "./transformers/defaults.js";
 function chunkArray(arr, size) {
     const chunks = [];
     for (let i = 0; i < arr.length; i += size) {
@@ -11,8 +11,8 @@ function chunkArray(arr, size) {
 }
 const redaxiosInstance = redaxios.default ?? redaxios;
 function escapeFilterValue(value) {
-    if (typeof value === 'string') {
-        return `\`${value.replaceAll('`', '')}\``;
+    if (typeof value === "string") {
+        return `\`${value.replaceAll("`", "")}\``;
     }
     if (Array.isArray(value)) {
         return value.map(escapeFilterValue);
@@ -25,17 +25,17 @@ const filterOperators = {
     gte: (k, v) => `${k}:>=${v}`,
     lt: (k, v) => `${k}:<${v}`,
     lte: (k, v) => `${k}:<=${v}`,
-    notIn: (k, v) => `${k}:!=[${v.join(',')}]`,
+    notIn: (k, v) => `${k}:!=[${v.join(",")}]`,
 };
 const arkToTsense = {
-    string: 'string',
-    number: 'float',
-    'number.integer': 'int64',
-    'number % 1': 'int64',
-    boolean: 'bool',
-    'string[]': 'string[]',
-    'number[]': 'float[]',
-    'boolean[]': 'bool[]',
+    string: "string",
+    number: "float",
+    "number.integer": "int64",
+    "number % 1": "int64",
+    boolean: "bool",
+    "string[]": "string[]",
+    "number[]": "float[]",
+    "boolean[]": "bool[]",
 };
 export class TSense {
     options;
@@ -49,27 +49,27 @@ export class TSense {
         this.options = options;
         this.axios = redaxiosInstance.create({
             baseURL: `${options.connection.protocol}://${options.connection.host}:${options.connection.port}`,
-            headers: { 'X-TYPESENSE-API-KEY': options.connection.apiKey },
+            headers: { "X-TYPESENSE-API-KEY": options.connection.apiKey },
         });
         this.fields = this.extractFields(options.transformers ?? defaultTransformers);
         this.dataSyncConfig = options.dataSync;
     }
     getBaseType(expression, domain) {
-        if (domain && domain !== 'undefined')
+        if (domain && domain !== "undefined")
             return domain;
-        return expression.replace(/ \| undefined$/, '');
+        return expression.replace(/ \| undefined$/, "");
     }
     inferType(arkType) {
         const direct = arkToTsense[arkType];
         if (direct)
             return direct;
-        if (arkType.includes('[]'))
-            return 'object[]';
+        if (arkType.includes("[]"))
+            return "object[]";
         if (arkType.includes("'") || arkType.includes('"'))
-            return 'string';
-        if (arkType.includes('{') || arkType.includes('|'))
-            return 'object';
-        return 'string';
+            return "string";
+        if (arkType.includes("{") || arkType.includes("|"))
+            return "object";
+        return "string";
     }
     serializeDoc(doc) {
         const result = { ...doc };
@@ -100,7 +100,7 @@ export class TSense {
         if (Array.isArray(value)) {
             return value.map((v) => transformer.serialize(v));
         }
-        if (typeof value === 'object' &&
+        if (typeof value === "object" &&
             value !== null &&
             Object.getPrototypeOf(value) === Object.prototype) {
             const result = {};
@@ -127,7 +127,7 @@ export class TSense {
             const branches = prop.value.branches ?? [];
             const enumValues = [];
             for (const branch of branches) {
-                if (typeof branch.unit === 'string') {
+                if (typeof branch.unit === "string") {
                     enumValues.push(branch.unit);
                 }
             }
@@ -143,7 +143,7 @@ export class TSense {
                     name: prop.key,
                     type: transformer.storageType,
                     sourceExpression: expression,
-                    optional: prop.kind === 'optional',
+                    optional: prop.kind === "optional",
                     facet: meta?.facet,
                     sort: meta?.sort,
                     index: meta?.index,
@@ -156,7 +156,7 @@ export class TSense {
                 name: prop.key,
                 type,
                 sourceExpression: expression,
-                optional: prop.kind === 'optional',
+                optional: prop.kind === "optional",
                 facet: meta?.facet,
                 sort: meta?.sort,
                 index: meta?.index,
@@ -180,7 +180,7 @@ export class TSense {
             const escapedLte = escapeFilterValue(value.lte);
             const parts = [`${key}:[${escaped}..${escapedLte}]`];
             for (const [op, opValue] of Object.entries(value)) {
-                if (op === 'gte' || op === 'lte' || opValue == null)
+                if (op === "gte" || op === "lte" || opValue == null)
                     continue;
                 const builder = filterOperators[op];
                 if (builder) {
@@ -206,34 +206,34 @@ export class TSense {
             const [key, rawValue] = entry;
             if (rawValue == null)
                 continue;
-            if (key === 'OR') {
+            if (key === "OR") {
                 const orParts = [];
                 for (const condition of rawValue) {
                     const inner = this.buildFilter(condition);
                     if (!inner.length) {
                         continue;
                     }
-                    orParts.push(`(${inner.join('&&')})`);
+                    orParts.push(`(${inner.join("&&")})`);
                 }
                 if (!orParts.length) {
                     continue;
                 }
-                result.push(`(${orParts.join('||')})`);
+                result.push(`(${orParts.join("||")})`);
                 continue;
             }
             const value = this.serializeFilterValue(key, rawValue);
             const escaped = escapeFilterValue(value);
-            if (typeof escaped === 'string' ||
-                typeof escaped === 'number' ||
-                typeof escaped === 'boolean') {
+            if (typeof escaped === "string" ||
+                typeof escaped === "number" ||
+                typeof escaped === "boolean") {
                 result.push(`${key}:=${escaped}`);
                 continue;
             }
             if (Array.isArray(escaped)) {
-                result.push(`${key}:[${escaped.join(',')}]`);
+                result.push(`${key}:[${escaped.join(",")}]`);
                 continue;
             }
-            if (typeof value === 'object' && value !== null) {
+            if (typeof value === "object" && value !== null) {
                 result.push(...this.buildObjectFilter(key, value));
             }
         }
@@ -248,7 +248,7 @@ export class TSense {
             if (value == null) {
                 continue;
             }
-            if (key === 'OR') {
+            if (key === "OR") {
                 for (const condition of value) {
                     this.validateFilterFields(condition);
                 }
@@ -264,7 +264,7 @@ export class TSense {
     validateFields(fields) {
         const valid = new Set(this.fields.map((f) => f.name));
         for (const field of fields) {
-            if (field !== 'score' && !valid.has(field)) {
+            if (field !== "score" && !valid.has(field)) {
                 throw new Error(`INVALID_FIELD: ${field}`);
             }
         }
@@ -276,7 +276,7 @@ export class TSense {
         if (Array.isArray(value)) {
             return value.map((v) => isRelativeDate(v) ? resolveRelativeDate(v, this.options.timezone) : v);
         }
-        if (typeof value === 'object' &&
+        if (typeof value === "object" &&
             value !== null &&
             !(value instanceof Date)) {
             const result = {};
@@ -296,7 +296,7 @@ export class TSense {
             if (value == null) {
                 continue;
             }
-            if (key === 'OR') {
+            if (key === "OR") {
                 result.OR = value.map((f) => this.resolveFilterDates(f));
                 continue;
             }
@@ -311,32 +311,32 @@ export class TSense {
         if (!parts.length) {
             return;
         }
-        return `(${parts.join('&&')})`;
+        return `(${parts.join("&&")})`;
     }
     combineFilterExpressions(...filters) {
         return filters
             .map((filter) => this.buildFilterExpression(filter))
             .filter((filter) => filter != null)
-            .join('&&');
+            .join("&&");
     }
     buildSort(options) {
         if (!options.sortBy)
             return;
         const result = [];
         for (const item of options.sortBy) {
-            const [field, direction] = item.split(':');
-            if (field === 'undefined')
+            const [field, direction] = item.split(":");
+            if (field === "undefined")
                 continue;
-            const realField = field === 'score' ? '_text_match' : field;
+            const realField = field === "score" ? "_text_match" : field;
             result.push(`${realField}:${direction}`);
         }
-        return result.join(',');
+        return result.join(",");
     }
     async create() {
-        const enableNested = this.fields.some((f) => f.type === 'object' || f.type === 'object[]');
+        const enableNested = this.fields.some((f) => f.type === "object" || f.type === "object[]");
         await this.axios({
-            method: 'POST',
-            url: '/collections',
+            method: "POST",
+            url: "/collections",
             data: {
                 name: this.options.name,
                 fields: this.fields,
@@ -348,14 +348,14 @@ export class TSense {
     }
     async drop() {
         await this.axios({
-            method: 'DELETE',
+            method: "DELETE",
             url: `/collections/${this.options.name}`,
         });
     }
     async get(id) {
         await this.ensureSynced();
         const { data } = await this.axios({
-            method: 'GET',
+            method: "GET",
             url: `/collections/${this.options.name}/documents/${id}`,
         }).catch((e) => {
             if (e.status === 404)
@@ -367,7 +367,7 @@ export class TSense {
     async delete(id) {
         await this.ensureSynced();
         const { data } = await this.axios({
-            method: 'DELETE',
+            method: "DELETE",
             url: `/collections/${this.options.name}/documents/${id}`,
         }).catch((e) => {
             if (e.status === 404)
@@ -379,10 +379,10 @@ export class TSense {
     async deleteManyWithFilterBy(filterBy) {
         await this.ensureSynced();
         if (!filterBy) {
-            throw new Error('FILTER_REQUIRED');
+            throw new Error("FILTER_REQUIRED");
         }
         const { data } = await this.axios({
-            method: 'DELETE',
+            method: "DELETE",
             url: `/collections/${this.options.name}/documents`,
             params: { filter_by: filterBy },
         });
@@ -395,7 +395,7 @@ export class TSense {
         await this.ensureSynced();
         const serialized = this.serializeDoc(data);
         const { data: updated } = await this.axios({
-            method: 'PATCH',
+            method: "PATCH",
             url: `/collections/${this.options.name}/documents/${id}`,
             data: serialized,
         });
@@ -404,11 +404,11 @@ export class TSense {
     async updateManyWithFilterBy(filterBy, data) {
         await this.ensureSynced();
         if (!filterBy) {
-            throw new Error('FILTER_REQUIRED');
+            throw new Error("FILTER_REQUIRED");
         }
         const serialized = this.serializeDoc(data);
         const { data: result } = await this.axios({
-            method: 'PATCH',
+            method: "PATCH",
             url: `/collections/${this.options.name}/documents`,
             params: { filter_by: filterBy },
             data: serialized,
@@ -426,15 +426,15 @@ export class TSense {
         this.validateFields(queryByFields);
         if (options.sortBy) {
             this.validateFields(options.sortBy
-                .map((s) => s.split(':')[0])
-                .filter((f) => f !== 'undefined'));
+                .map((s) => s.split(":")[0])
+                .filter((f) => f !== "undefined"));
         }
         if (options.facetBy) {
             this.validateFields(options.facetBy);
         }
-        const queryBy = queryByFields.join(',');
+        const queryBy = queryByFields.join(",");
         const params = {
-            q: options.query ?? '*',
+            q: options.query ?? "*",
             query_by: queryBy,
         };
         const sortBy = this.buildSort(options);
@@ -446,20 +446,20 @@ export class TSense {
             params.page = options.page;
         if (options.limit != null)
             params.per_page = options.limit;
-        const facetBy = options.facetBy?.join(',');
+        const facetBy = options.facetBy?.join(",");
         if (facetBy)
             params.facet_by = facetBy;
-        if ('pick' in options && options.pick) {
-            params.include_fields = options.pick.join(',');
+        if ("pick" in options && options.pick) {
+            params.include_fields = options.pick.join(",");
         }
-        if ('omit' in options && options.omit) {
-            params.exclude_fields = options.omit.join(',');
+        if ("omit" in options && options.omit) {
+            params.exclude_fields = options.omit.join(",");
         }
         const highlight = options.highlight;
-        const highlightOpts = typeof highlight === 'object' ? highlight : undefined;
+        const highlightOpts = typeof highlight === "object" ? highlight : undefined;
         if (highlightOpts) {
             if (highlightOpts.fields) {
-                params.highlight_fields = highlightOpts.fields.join(',');
+                params.highlight_fields = highlightOpts.fields.join(",");
             }
             if (highlightOpts.startTag) {
                 params.highlight_start_tag = highlightOpts.startTag;
@@ -469,7 +469,7 @@ export class TSense {
             }
         }
         const { data: res } = await this.axios({
-            method: 'GET',
+            method: "GET",
             url: `/collections/${this.options.name}/documents/search`,
             params,
         });
@@ -532,19 +532,19 @@ export class TSense {
         await this.ensureSynced();
         if (!filterBy) {
             const { data } = await this.axios({
-                method: 'GET',
+                method: "GET",
                 url: `/collections/${this.options.name}`,
             });
             return data.num_documents;
         }
         const params = {
-            q: '*',
+            q: "*",
             query_by: this.options.defaultSearchField,
             per_page: 0,
             filter_by: filterBy,
         };
         const { data } = await this.axios({
-            method: 'GET',
+            method: "GET",
             url: `/collections/${this.options.name}/documents/search`,
             params,
         });
@@ -565,26 +565,26 @@ export class TSense {
         }
         const payload = items
             .map((item) => JSON.stringify(this.serializeDoc(item)))
-            .join('\n');
-        const params = { action: 'upsert' };
+            .join("\n");
+        const params = { action: "upsert" };
         if (this.options.batchSize) {
             params.batch_size = this.options.batchSize;
         }
         const { data } = await this.axios({
-            method: 'POST',
+            method: "POST",
             url: `/collections/${this.options.name}/documents/import`,
-            headers: { 'Content-Type': 'text/plain' },
+            headers: { "Content-Type": "text/plain" },
             params,
             data: payload,
         });
-        if (typeof data === 'string') {
-            return data.split('\n').map((v) => JSON.parse(v));
+        if (typeof data === "string") {
+            return data.split("\n").map((v) => JSON.parse(v));
         }
         return [data];
     }
     async syncData(options) {
         if (!this.dataSyncConfig) {
-            throw new Error('DATA_SYNC_NOT_CONFIGURED');
+            throw new Error("DATA_SYNC_NOT_CONFIGURED");
         }
         const chunkSize = options?.chunkSize ?? this.dataSyncConfig.chunkSize ?? 500;
         const ids = options?.ids ?? (await this.dataSyncConfig.getAllIds());
@@ -621,12 +621,12 @@ export class TSense {
     }
     async exportIds() {
         const { data } = await this.axios({
-            method: 'GET',
+            method: "GET",
             url: `/collections/${this.options.name}/documents/export`,
-            params: { include_fields: 'id' },
+            params: { include_fields: "id" },
         });
         return data
-            .split('\n')
+            .split("\n")
             .filter((line) => line.length)
             .map((line) => JSON.parse(line).id);
     }

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import type { Type } from 'arktype';
-import type { FieldTransformer } from './transformers/types.js';
+import type { Type } from "arktype";
+import type { FieldTransformer } from "./transformers/types.js";
 type BaseIfArray<T> = T extends (infer Q)[] ? Q : T;
 export type FieldSchema = {
     name: string;
@@ -32,7 +32,7 @@ export type SearchApiResponse<T> = {
 export type ConnectionConfig = {
     host: string;
     port: number;
-    protocol: 'http' | 'https';
+    protocol: "http" | "https";
     apiKey: string;
     timeout?: number;
 };
@@ -40,16 +40,16 @@ export type TsenseOptions<T extends Type> = {
     name: string;
     schema: T;
     connection: ConnectionConfig;
-    defaultSearchField?: keyof T['infer'];
-    defaultSortingField?: keyof T['infer'];
+    defaultSearchField?: keyof T["infer"];
+    defaultSortingField?: keyof T["infer"];
     batchSize?: number;
     validateOnUpsert?: boolean;
     autoSyncSchema?: boolean;
     timezone?: string;
     transformers?: FieldTransformer[];
-    dataSync?: SyncConfig<T['infer']>;
+    dataSync?: SyncConfig<T["infer"]>;
 };
-export type RelativeDateUnit = 'day' | 'week' | 'month';
+export type RelativeDateUnit = "day" | "week" | "month";
 export type RelativeDate = {
     startOf: RelativeDateUnit;
 } | {
@@ -88,12 +88,12 @@ export type HighlightOptions<T> = {
     startTag?: string;
     endTag?: string;
 };
-type SortableField<T> = Extract<keyof T, string> | 'score';
+type SortableField<T> = Extract<keyof T, string> | "score";
 export type BaseSearchOptions<T> = {
     query?: string;
     queryBy?: (keyof T)[];
     filter?: FilterFor<T>;
-    sortBy?: `${SortableField<T>}:${'asc' | 'desc'}`[];
+    sortBy?: `${SortableField<T>}:${"asc" | "desc"}`[];
     facetBy?: (keyof T)[];
     page?: number;
     limit?: number;
@@ -144,7 +144,7 @@ export type SearchListOptions<T> = {
     query?: string;
     queryBy?: (keyof T)[];
     filter?: FilterFor<T>;
-    sortBy: `${Extract<keyof T, string>}:${'asc' | 'desc'}`;
+    sortBy: `${Extract<keyof T, string>}:${"asc" | "desc"}`;
     limit?: number;
     cursor?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsense",
-  "version": "0.2.0-next.5",
+  "version": "0.2.0-next.7",
   "private": false,
   "description": "Opinionated, fully typed typesense client",
   "keywords": [