@firstnoodle-ui/bui 0.0.66 → 0.0.67

package/dist/filtering/composables/useFilters.d.ts

@@ -1,15 +1,5 @@
-import { Ref } from 'vue';
-import { LocationQuery } from 'vue-router';
-import { Filter, TypedSorting } from '../types';
-type FilterOptions<T> = {
-    groupId: string;
-    filters: Filter<T>[];
-    defaultSorting: TypedSorting<T>;
-    sortingMethod?: (sorting: TypedSorting<T>, items: T[]) => T[];
-    items?: Ref<T[]>;
-    remoteFilterMethod?: (sorting: TypedSorting<T>, filters: Filter<T>[]) => Promise<T[]>;
-};
-export declare const useFilters: <T>({ filters, groupId, items, remoteFilterMethod, defaultSorting, sortingMethod }: FilterOptions<T>) => {
+import { Filter, FilterOptions, NestedKeyOf, TypedSorting } from '../types';
+export declare const useFilters: <T, AllowedSortingFields extends NestedKeyOf<T>>({ groupId, filters, sorting, items, remoteFilterMethod }: FilterOptions<T, AllowedSortingFields>) => {
     activeFilters: import('vue').ComputedRef<{
         id: string;
         name: string;
@@ -21,14 +11,14 @@ export declare const useFilters: <T>({ filters, groupId, items, remoteFilterMeth
         value: import('..').FilterValue;
         execute: (value: import('..').FilterValue, operator: import('..').Operator, entity: T) => boolean;
     }[]>;
-    activeSorting: Ref<{
+    activeSorting: import('vue').Ref<{
         direction: import('..').SortingDirection;
-        field: import('vue').UnwrapRef<keyof T>;
-    }, TypedSorting<T> | {
+        field: import('vue').UnwrapRef<AllowedSortingFields>;
+    }, TypedSorting<T, AllowedSortingFields> | {
         direction: import('..').SortingDirection;
-        field: import('vue').UnwrapRef<keyof T>;
+        field: import('vue').UnwrapRef<AllowedSortingFields>;
     }>;
-    availableFilters: Ref<{
+    availableFilters: import('vue').Ref<{
         id: string;
         name: string;
         component: string;
@@ -50,10 +40,8 @@ export declare const useFilters: <T>({ filters, groupId, items, remoteFilterMeth
         execute: (value: import('..').FilterValue, operator: import('..').Operator, entity: T) => boolean;
     }[]>;
     filteringActive: import('vue').ComputedRef<boolean>;
-    filteredItems: Ref<import('@vue/reactivity').UnwrapRefSimple<T>[], T[] | import('@vue/reactivity').UnwrapRefSimple<T>[]>;
-    loadingItems: Ref<boolean, boolean>;
+    filteredItems: import('vue').Ref<import('@vue/reactivity').UnwrapRefSimple<T>[], T[] | import('@vue/reactivity').UnwrapRefSimple<T>[]>;
+    loadingItems: import('vue').Ref<boolean, boolean>;
     applyFilters: () => Promise<void>;
     clearFilters: () => Promise<void>;
-    updateFilters: (routeQuery: LocationQuery) => void;
 };
-export {};

package/dist/filtering/types.d.ts

@@ -1,9 +1,17 @@
+import { Ref } from 'vue';
 export declare const sortingDirections: readonly ["asc", "desc"];
 export type SortingDirection = (typeof sortingDirections)[number];
 export declare const operators: readonly ["=", "!=", "<", "<=", ">", ">="];
 export type Operator = (typeof operators)[number];
 export declare const operatorLetters: readonly ["eq", "ne", "lt", "le", "gt", "ge"];
 export type OperatorLetters = (typeof operatorLetters)[number];
+export type FilterOptions<T, AllowedSortingFields extends NestedKeyOf<T>> = {
+    groupId: string;
+    filters: Filter<T>[];
+    sorting: SortingConfig<T, AllowedSortingFields>;
+    items?: Ref<T[]>;
+    remoteFilterMethod?: (sorting: TypedSorting<T, AllowedSortingFields>, filters: Filter<T>[]) => Promise<T[]>;
+};
 export type FilterValue = string | null;
 export type Filter<FilteredEntity> = {
     id: string;
@@ -29,9 +37,16 @@ export type ParsedSortingQuery = {
     direction: SortingDirection;
     field: string;
 };
-export type TypedSorting<T> = {
+export type NestedKeyOf<T> = T extends object ? {
+    [K in keyof T & string]: T[K] extends object ? K | `${K}.${NestedKeyOf<T[K]>}` : K;
+}[keyof T & string] : never;
+export type TypedSorting<T, AllowedFields extends NestedKeyOf<T>> = {
     direction: SortingDirection;
-    field: keyof T;
+    field: AllowedFields;
+};
+export type SortingConfig<T, AllowedSortingFields extends NestedKeyOf<T>> = {
+    default: TypedSorting<T, AllowedSortingFields>;
+    sortingMethod: (sorting: TypedSorting<T, AllowedSortingFields>, items: T[]) => T[];
 };
 export type ParsedFiltersAndSorting = {
     sorting: ParsedSortingQuery | undefined;

package/dist/filtering/utils/sortByField.d.ts

@@ -1,5 +1,5 @@
-import { TypedSorting } from '../types';
+import { NestedKeyOf, TypedSorting } from '../types';
 /**
  * Sorts an array of objects by a given field, automatically detecting the field type (string, number, or date)
  */
-export declare function sortByField<T extends Record<string, any>>(sorting: TypedSorting<T>, items: T[]): T[];
+export declare function sortByField<T extends Record<string, any>, AllowedSortingFields extends NestedKeyOf<T>>(sorting: TypedSorting<T, AllowedSortingFields>, items: T[]): T[];