@archbase/components 3.0.0

package/src/filters/hooks/useArchbaseFilterPresets.ts

@@ -0,0 +1,157 @@
+import { useCallback, useMemo } from 'react';
+import { useLocalStorage } from '@mantine/hooks';
+import { notifications } from '@mantine/notifications';
+import React from 'react';
+import type {
+  ArchbaseActiveFilter,
+  SavedFilterPreset,
+  UseArchbaseFilterPresetsOptions,
+  UseArchbaseFilterPresetsReturn,
+} from '../ArchbaseCompositeFilters.types';
+
+/**
+ * Hook para gerenciar presets de filtros salvos no localStorage
+ *
+ * @param options - Opções de configuração
+ * @returns Objeto com presets e ações para gerenciá-los
+ *
+ * @example
+ * ```ts
+ * const {
+ *   presets,
+ *   sortedPresets,
+ *   savePreset,
+ *   loadPreset,
+ *   deletePreset,
+ *   toggleFavorite
+ * } = useArchbaseFilterPresets({
+ *   storageKey: 'my-app-filters',
+ *   onLoad: (filters) => console.log('Loaded', filters)
+ * });
+ * ```
+ */
+export function useArchbaseFilterPresets(
+  options: UseArchbaseFilterPresetsOptions = {}
+): UseArchbaseFilterPresetsReturn {
+  const { storageKey = 'archbase-filter-presets', onLoad } = options;
+
+  const [savedPresets, setSavedPresets] = useLocalStorage<SavedFilterPreset[]>({
+    key: storageKey,
+    defaultValue: [],
+  });
+
+  // Presets ordenados (favoritos primeiro)
+  const sortedPresets = useMemo(() => {
+    return [...savedPresets].sort((a, b) => {
+      if (a.isFavorite && !b.isFavorite) return -1;
+      if (!a.isFavorite && b.isFavorite) return 1;
+      return b.createdAt - a.createdAt;
+    });
+  }, [savedPresets]);
+
+  // Salva um preset
+  const savePreset = useCallback(
+    (filters: ArchbaseActiveFilter[], name?: string): SavedFilterPreset | null => {
+      if (filters.length === 0) {
+        notifications.show({
+          title: String('No filters to save'),
+          message: String('Add some filters before saving a preset'),
+          color: 'yellow',
+        });
+        return null;
+      }
+
+      const presetName = name || prompt(String('Enter a name for this filter preset:'));
+      if (!presetName) return null;
+
+      const newPreset: SavedFilterPreset = {
+        id: `preset-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+        name: presetName,
+        filters,
+        createdAt: Date.now(),
+        isFavorite: false,
+      };
+
+      setSavedPresets(prev => [...prev, newPreset]);
+
+      notifications.show({
+        title: String('Preset saved'),
+        message: `"${presetName}" has been saved`,
+        color: 'green',
+        icon: React.createElement(
+          'svg',
+          { xmlns: 'http://www.w3.org/2000/svg', width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
+          React.createElement('path', { d: 'M20 6L9 17l-5-5' })
+        ),
+      });
+
+      return newPreset;
+    },
+    [setSavedPresets]
+  );
+
+  // Carrega um preset
+  const loadPreset = useCallback(
+    (preset: SavedFilterPreset) => {
+      onLoad?.(preset.filters);
+      notifications.show({
+        title: String('Preset loaded'),
+        message: `"${preset.name}" has been applied`,
+        color: 'blue',
+      });
+    },
+    [onLoad]
+  );
+
+  // Remove um preset
+  const deletePreset = useCallback(
+    (presetId: string) => {
+      setSavedPresets(prev => {
+        const preset = prev.find(p => p.id === presetId);
+        const updated = prev.filter(p => p.id !== presetId);
+        if (preset) {
+          notifications.show({
+            title: String('Preset deleted'),
+            message: `"${preset.name}" has been removed`,
+            color: 'red',
+          });
+        }
+        return updated;
+      });
+    },
+    [setSavedPresets]
+  );
+
+  // Alterna favorito
+  const toggleFavorite = useCallback(
+    (presetId: string) => {
+      setSavedPresets(prev =>
+        prev.map(p =>
+          p.id === presetId ? { ...p, isFavorite: !p.isFavorite } : p
+        )
+      );
+    },
+    [setSavedPresets]
+  );
+
+  // Atualiza um preset
+  const updatePreset = useCallback(
+    (presetId: string, updates: Partial<Omit<SavedFilterPreset, 'id'>>) => {
+      setSavedPresets(prev =>
+        prev.map(p => (p.id === presetId ? { ...p, ...updates } : p))
+      );
+    },
+    [setSavedPresets]
+  );
+
+  return {
+    presets: savedPresets,
+    sortedPresets,
+    savePreset,
+    loadPreset,
+    deletePreset,
+    updatePreset,
+    toggleFavorite,
+    hasPresets: savedPresets.length > 0,
+  };
+}

package/src/filters/hooks/useArchbaseFilters.ts

@@ -0,0 +1,279 @@
+import { useCallback, useMemo, useState } from 'react';
+import type {
+  ArchbaseActiveFilter,
+  ArchbaseFilterDefinition,
+  UseArchbaseFiltersOptions,
+  UseArchbaseFiltersReturn,
+  ApiFilterFormat,
+} from '../ArchbaseCompositeFilters.types';
+import {
+  convertToRSQL,
+  convertToApiFormatList,
+  generateFilterId,
+  validateFilterValue,
+  getDisplayValue,
+} from '../ArchbaseCompositeFilters.utils';
+
+/**
+ * Hook principal para gerenciamento de filtros com conversão RSQL
+ *
+ * @param filterDefinitions - Definições dos campos filtráveis
+ * @param options - Opções de configuração
+ * @returns Objeto com estado e ações para gerenciar filtros
+ *
+ * @example
+ * ```ts
+ * const filters: ArchbaseFilterDefinition[] = [
+ *   { key: 'nome', label: 'Nome', type: 'text' },
+ *   { key: 'idade', label: 'Idade', type: 'integer' }
+ * ];
+ *
+ * const {
+ *   activeFilters,
+ *   rsqlQuery,
+ *   addFilter,
+ *   removeFilter,
+ *   clearFilters
+ * } = useArchbaseFilters(filters);
+ * ```
+ */
+export function useArchbaseFilters(
+  filterDefinitions: ArchbaseFilterDefinition[],
+  options?: UseArchbaseFiltersOptions
+): UseArchbaseFiltersReturn {
+  const [activeFilters, setActiveFilters] = useState<ArchbaseActiveFilter[]>(
+    options?.initialFilters || []
+  );
+
+  // Gera a query RSQL atual
+  const rsqlQuery = useMemo(() => {
+    return convertToRSQL(activeFilters);
+  }, [activeFilters]);
+
+  // Notifica mudança nos filtros
+  const handleFiltersChange = useCallback(
+    (newFilters: ArchbaseActiveFilter[]) => {
+      setActiveFilters(newFilters);
+      options?.onFiltersChange?.(newFilters, convertToRSQL(newFilters));
+    },
+    [options]
+  );
+
+  // Adiciona um novo filtro
+  const addFilter = useCallback(
+    (filter: Omit<ArchbaseActiveFilter, 'id'>) => {
+      const fieldDef = filterDefinitions.find(f => f.key === filter.key);
+      if (!fieldDef) {
+        console.warn(`Field definition not found for key: ${filter.key}`);
+        return;
+      }
+
+      // Valida o valor
+      if (!validateFilterValue(filter.value, filter.type, filter.operator)) {
+        console.warn(`Invalid filter value for ${filter.key}`);
+        return;
+      }
+
+      const newFilter: ArchbaseActiveFilter = {
+        ...filter,
+        id: generateFilterId(),
+        displayValue: getDisplayValue(
+          filter.value,
+          filter.type,
+          filter.operator,
+          fieldDef.options
+        ),
+      };
+
+      // Verifica se já existe um filtro para o mesmo campo
+      const existingIndex = activeFilters.findIndex(f => f.key === filter.key);
+      if (existingIndex >= 0) {
+        // Substitui o filtro existente
+        const newFilters = [...activeFilters];
+        newFilters[existingIndex] = newFilter;
+        handleFiltersChange(newFilters);
+      } else {
+        // Adiciona novo filtro
+        handleFiltersChange([...activeFilters, newFilter]);
+      }
+    },
+    [activeFilters, filterDefinitions, handleFiltersChange]
+  );
+
+  // Remove um filtro pelo ID
+  const removeFilter = useCallback(
+    (id: string) => {
+      handleFiltersChange(activeFilters.filter(f => f.id !== id));
+    },
+    [activeFilters, handleFiltersChange]
+  );
+
+  // Limpa todos os filtros
+  const clearFilters = useCallback(() => {
+    handleFiltersChange([]);
+  }, [handleFiltersChange]);
+
+  // Atualiza um filtro existente
+  const updateFilter = useCallback(
+    (id: string, updates: Partial<ArchbaseActiveFilter>) => {
+      handleFiltersChange(
+        activeFilters.map(f => (f.id === id ? { ...f, ...updates } : f))
+      );
+    },
+    [activeFilters, handleFiltersChange]
+  );
+
+  // Define todos os filtros de uma vez
+  const setFilters = useCallback(
+    (filters: ArchbaseActiveFilter[]) => {
+      handleFiltersChange(filters);
+    },
+    [handleFiltersChange]
+  );
+
+  // Converte para RSQL
+  const toRSQL = useCallback(() => {
+    return convertToRSQL(activeFilters);
+  }, [activeFilters]);
+
+  // Converte para formato de API
+  const toApiFormat = useCallback((): ApiFilterFormat[] => {
+    return convertToApiFormatList(activeFilters);
+  }, [activeFilters]);
+
+  // Verifica se existe um filtro para uma chave
+  const hasFilter = useCallback(
+    (key: string) => {
+      return activeFilters.some(f => f.key === key);
+    },
+    [activeFilters]
+  );
+
+  // Obtém um filtro por chave
+  const getFilter = useCallback(
+    (key: string) => {
+      return activeFilters.find(f => f.key === key);
+    },
+    [activeFilters]
+  );
+
+  return {
+    activeFilters,
+    rsqlQuery,
+    addFilter,
+    removeFilter,
+    clearFilters,
+    updateFilter,
+    setFilters,
+    toRSQL,
+    toApiFormat,
+    filtersCount: activeFilters.length,
+    hasFilter,
+    getFilter,
+  };
+}
+
+/**
+ * Hook simplificado para gerenciamento de filtros com valor controlado
+ */
+export function useArchbaseFiltersControlled(
+  filterDefinitions: ArchbaseFilterDefinition[],
+  value: ArchbaseActiveFilter[],
+  onChange: (filters: ArchbaseActiveFilter[], rsql?: string) => void
+): Omit<UseArchbaseFiltersReturn, 'activeFilters' | 'rsqlQuery'> & {
+  activeFilters: ArchbaseActiveFilter[];
+  rsqlQuery: string | undefined;
+} {
+  const rsqlQuery = useMemo(() => convertToRSQL(value), [value]);
+
+  const addFilter = useCallback(
+    (filter: Omit<ArchbaseActiveFilter, 'id'>) => {
+      const fieldDef = filterDefinitions.find(f => f.key === filter.key);
+      if (!fieldDef || !validateFilterValue(filter.value, filter.type, filter.operator)) {
+        return;
+      }
+
+      const newFilter: ArchbaseActiveFilter = {
+        ...filter,
+        id: generateFilterId(),
+        displayValue: getDisplayValue(filter.value, filter.type, filter.operator, fieldDef.options),
+      };
+
+      const existingIndex = value.findIndex(f => f.key === filter.key);
+      let newFilters: ArchbaseActiveFilter[];
+      if (existingIndex >= 0) {
+        newFilters = [...value];
+        newFilters[existingIndex] = newFilter;
+      } else {
+        newFilters = [...value, newFilter];
+      }
+
+      onChange(newFilters, convertToRSQL(newFilters));
+    },
+    [filterDefinitions, value, onChange]
+  );
+
+  const removeFilter = useCallback(
+    (id: string) => {
+      const newFilters = value.filter(f => f.id !== id);
+      onChange(newFilters, convertToRSQL(newFilters));
+    },
+    [value, onChange]
+  );
+
+  const clearFilters = useCallback(() => {
+    onChange([], undefined);
+  }, [onChange]);
+
+  const updateFilter = useCallback(
+    (id: string, updates: Partial<ArchbaseActiveFilter>) => {
+      const newFilters = value.map(f => (f.id === id ? { ...f, ...updates } : f));
+      onChange(newFilters, convertToRSQL(newFilters));
+    },
+    [value, onChange]
+  );
+
+  const setFilters = useCallback(
+    (filters: ArchbaseActiveFilter[]) => {
+      onChange(filters, convertToRSQL(filters));
+    },
+    [onChange]
+  );
+
+  const toRSQL = useCallback(() => {
+    return rsqlQuery;
+  }, [rsqlQuery]);
+
+  const toApiFormat = useCallback(() => {
+    return convertToApiFormatList(value);
+  }, [value]);
+
+  const hasFilter = useCallback(
+    (key: string) => {
+      return value.some(f => f.key === key);
+    },
+    [value]
+  );
+
+  const getFilter = useCallback(
+    (key: string) => {
+      return value.find(f => f.key === key);
+    },
+    [value]
+  );
+
+  return {
+    activeFilters: value,
+    rsqlQuery,
+    addFilter,
+    removeFilter,
+    clearFilters,
+    updateFilter,
+    setFilters,
+    toRSQL,
+    toApiFormat,
+    filtersCount: value.length,
+    hasFilter,
+    getFilter,
+  };
+}

package/src/filters/hooks/useArchbaseQuickFilters.ts

@@ -0,0 +1,80 @@
+import { useCallback, useState } from 'react';
+import type {
+  ArchbaseActiveFilter,
+  QuickFilterPreset,
+  UseArchbaseQuickFiltersReturn,
+} from '../ArchbaseCompositeFilters.types';
+
+/**
+ * Hook para gerenciar filtros rápidos predefinidos
+ *
+ * @param predefinedFilters - Filtros rápidos predefinidos
+ * @param onApply - Callback quando um filtro rápido é aplicado
+ * @returns Objeto com filtros rápidos e ações
+ *
+ * @example
+ * ```ts
+ * const quickFilters: QuickFilterPreset[] = [
+ *   {
+ *     id: 'active-users',
+ *     name: 'Active Users',
+ *     filters: [
+ *       { key: 'status', label: 'Status', type: 'text', operator: '=', value: 'active', displayValue: 'active' }
+ *     ]
+ *   }
+ * ];
+ *
+ * const { quickFilters, applyQuickFilter } = useArchbaseQuickFilters(quickFilters, (filters) => {
+ *   console.log('Applied:', filters);
+ * });
+ * ```
+ */
+export function useArchbaseQuickFilters(
+  predefinedFilters: QuickFilterPreset[] = [],
+  onApply?: (filters: ArchbaseActiveFilter[]) => void
+): UseArchbaseQuickFiltersReturn {
+  const [quickFilters, setQuickFilters] = useState<QuickFilterPreset[]>(predefinedFilters);
+
+  // Aplica um filtro rápido
+  const applyQuickFilter = useCallback(
+    (presetId: string) => {
+      const preset = quickFilters.find(f => f.id === presetId);
+      if (!preset) {
+        console.warn(`Quick filter not found: ${presetId}`);
+        return;
+      }
+
+      // Adiciona IDs aos filtros
+      const filtersWithIds: ArchbaseActiveFilter[] = preset.filters.map(f => ({
+        ...f,
+        id: `quick-filter-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      }));
+
+      onApply?.(filtersWithIds);
+    },
+    [quickFilters, onApply]
+  );
+
+  // Adiciona um novo filtro rápido
+  const addQuickFilter = useCallback(
+    (preset: QuickFilterPreset) => {
+      setQuickFilters(prev => [...prev, preset]);
+    },
+    []
+  );
+
+  // Remove um filtro rápido
+  const removeQuickFilter = useCallback(
+    (presetId: string) => {
+      setQuickFilters(prev => prev.filter(f => f.id !== presetId));
+    },
+    []
+  );
+
+  return {
+    quickFilters,
+    applyQuickFilter,
+    addQuickFilter,
+    removeQuickFilter,
+  };
+}

package/src/filters/index.ts

@@ -0,0 +1,55 @@
+// Componente principal
+export { ArchbaseCompositeFilters } from './ArchbaseCompositeFilters';
+
+// Componentes
+export { FilterPill } from './components/FilterPill';
+
+// Hooks
+export {
+  useArchbaseFilters,
+  useArchbaseFiltersControlled,
+} from './hooks/useArchbaseFilters';
+export { useArchbaseFilterPresets } from './hooks/useArchbaseFilterPresets';
+export { useArchbaseFilterHistory } from './hooks/useArchbaseFilterHistory';
+export { useArchbaseQuickFilters } from './hooks/useArchbaseQuickFilters';
+
+// Utilitários
+export {
+  convertToRSQL,
+  convertToApiFormatList,
+  getDisplayValue,
+  getOperatorsForType,
+  getDefaultOperatorForType,
+  validateFilterValue,
+  generateFilterId,
+} from './ArchbaseCompositeFilters.utils';
+
+// Tipos
+export type {
+  ArchbaseFieldDataType,
+  ArchbaseFilterOperator,
+  ArchbaseFilterDefinition,
+  ArchbaseActiveFilter,
+  ArchbaseCompositeFiltersProps,
+  SavedFilterPreset,
+  FilterHistoryEntry,
+  QuickFilterPreset,
+  FilterValue,
+  FilterOption,
+  RSQLOutput,
+  FilterVariant,
+  InputStep,
+  ApiFilterFormat,
+  UseArchbaseFiltersOptions,
+  UseArchbaseFiltersReturn,
+  UseArchbaseFilterPresetsOptions,
+  UseArchbaseFilterPresetsReturn,
+  UseArchbaseFilterHistoryOptions,
+  UseArchbaseFilterHistoryReturn,
+  FilterPillProps,
+  FieldDropdownProps,
+  OperatorDropdownProps,
+  ValueDropdownProps,
+  ArchbaseCompositeFiltersStyles,
+  ArchbaseCompositeFiltersClassNames,
+} from './ArchbaseCompositeFilters.types';

package/src/forms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,QAAQ,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/src/forms/index.ts

@@ -0,0 +1,4 @@
+// Form Components - TODO: Implement
+export { Button as ArchbaseButton } from '@mantine/core';
+export { ActionIcon as ArchbaseActionIcon } from '@mantine/core';
+export { Fieldset as ArchbaseFieldset } from '@mantine/core';

package/src/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC"}

package/src/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useArchbaseListContext } from './useArchbaseListContext';
+export { useArchbaseVisible } from './useArchbaseVisible';
+export { useArchbaseNavigateParams } from './useArchbaseNavigateParams';
+export { useArchbaseContainerDimensions } from './useArchbaseContainerDimensions';
+export { useArchbaseElementSizeArea } from './useArchbaseElementSizeArea';

package/src/hooks/useArchbaseContainerDimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArchbaseContainerDimensions.d.ts","sourceRoot":"","sources":["useArchbaseContainerDimensions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,8BAA8B;;;CAyB1C,CAAA"}

package/src/hooks/useArchbaseContainerDimensions.ts

@@ -0,0 +1,28 @@
+import { useEffect, useState } from 'react'
+
+export const useArchbaseContainerDimensions = (myRef) => {
+  const [dimensions, setDimensions] = useState({ width: 0, height: 0 })
+
+  useEffect(() => {
+    const getDimensions = () => ({
+      width: myRef.current.offsetWidth,
+      height: myRef.current.offsetHeight
+    })
+
+    const handleResize = () => {
+      setDimensions(getDimensions())
+    }
+
+    if (myRef.current) {
+      setDimensions(getDimensions())
+    }
+
+    window.addEventListener('resize', handleResize)
+
+    return () => {
+      window.removeEventListener('resize', handleResize)
+    }
+  }, [myRef])
+
+  return dimensions
+}

package/src/hooks/useArchbaseElementSizeArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArchbaseElementSizeArea.d.ts","sourceRoot":"","sources":["useArchbaseElementSizeArea.ts"],"names":[],"mappings":"AAGA,UAAU,IAAI;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,iBAAS,0BAA0B,CAAC,CAAC,SAAS,WAAW,GAAG,cAAc,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,EAAE,IAAI,CAAC,CA4B9G;AAED,eAAe,0BAA0B,CAAC"}

package/src/hooks/useArchbaseElementSizeArea.ts

@@ -0,0 +1,39 @@
+import { useCallback, useState } from 'react';
+import { useEventListener, useIsomorphicLayoutEffect } from 'usehooks-ts';
+
+interface Size {
+	width: number;
+	height: number;
+}
+
+function useArchbaseElementSizeArea<T extends HTMLElement = HTMLDivElement>(): [(node: T | null) => void, Size] {
+	// Mutable values like 'ref.current' aren't valid dependencies
+	// because mutating them doesn't re-render the component.
+	// Instead, we use a state as a ref to be reactive.
+	const [ref, setRef] = useState<T | null>(null);
+	const [size, setSize] = useState<Size>({
+		width: 0,
+		height: 0,
+	});
+
+	// Prevent too many rendering using useCallback
+	const handleSize = useCallback(() => {
+		setSize({
+			width: ref?.offsetWidth || 0,
+			height: ref?.offsetHeight || 0,
+		});
+
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [ref?.offsetHeight, ref?.offsetWidth]);
+
+	useEventListener('resize', handleSize);
+
+	useIsomorphicLayoutEffect(() => {
+		handleSize();
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [ref?.offsetHeight, ref?.offsetWidth]);
+
+	return [setRef, size];
+}
+
+export { useArchbaseElementSizeArea };

package/src/hooks/useArchbaseListContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArchbaseListContext.d.ts","sourceRoot":"","sources":["useArchbaseListContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAEvE,wBAAgB,sBAAsB,CAAC,CAAC,EAAC,EAAE,qCAM1C"}

package/src/hooks/useArchbaseListContext.ts

@@ -0,0 +1,10 @@
+import { useContext } from "react"
+import { ArchbaseListContext, ArchbaseListContextValue } from "../list"
+
+export function useArchbaseListContext<T,ID>() {
+    const context = useContext<ArchbaseListContextValue<T,ID>>(ArchbaseListContext)
+    if (!context) {
+      throw new Error('useArchbaseListContext deve ser usado dentro de um ArchbaseListProvider')
+    }
+    return context
+}

package/src/hooks/useArchbaseNavigateParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArchbaseNavigateParams.d.ts","sourceRoot":"","sources":["useArchbaseNavigateParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAe,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAsB,MAAM,kBAAkB,CAAC;AAE3E,eAAO,MAAM,yBAAyB,mBAGf,MAAM,YAAY,eAAe,WAAW,mBAAmB,SAUnF,CAAC"}