@archbase/core 3.0.0

package/README.md

@@ -0,0 +1,42 @@
+# @archbase/core
+
+Core utilities and foundation for Archbase React v3.
+
+## Installation
+
+```bash
+npm install @archbase/core
+```
+
+## Features
+
+- 🎯 **Error Handling**: Comprehensive error boundary system
+- 🔧 **IOC Container**: Dependency injection with InversifyJS
+- 🌍 **Context Providers**: Global app context management
+- 🛠️ **Utilities**: 20+ utility functions for common operations
+- 🔍 **RSQL Parser**: Complete RSQL query parser
+
+## Usage
+
+```typescript
+import { 
+  ArchbaseError,
+  ArchbaseErrorBoundary,
+  ArchbaseAppContext,
+  withArchbaseErrorBoundary 
+} from '@archbase/core';
+
+// Error Boundary
+<ArchbaseErrorBoundary>
+  <YourApp />
+</ArchbaseErrorBoundary>
+
+// Global Context
+<ArchbaseAppContext.Provider value={appConfig}>
+  <YourApp />
+</ArchbaseAppContext.Provider>
+```
+
+## API Documentation
+
+Detailed API documentation coming soon...

package/dist/context/ArchbaseAppContext.d.ts

@@ -0,0 +1,43 @@
+import React, { ReactNode } from 'react';
+import { Container } from 'inversify';
+import { MantineTheme, MantineColorScheme, MantineThemeOverride } from '@mantine/core';
+import { ArchbaseUser } from '../types';
+export type ArchbaseLanguage = {
+    lang: string;
+    name: string;
+};
+interface ArchbaseAppContextValues {
+    user: ArchbaseUser | null;
+    owner: string | null;
+    selectedCompany: any | null;
+    theme: MantineTheme | null;
+    colorScheme: MantineColorScheme | null;
+    iocContainer: Container | null;
+    dateFormat: string;
+    dateTimeFormat: string;
+    timeFormat: string;
+    variant?: string;
+    languages?: ArchbaseLanguage[];
+    setCustomTheme?: (dark: MantineThemeOverride, light: MantineThemeOverride) => void;
+}
+declare const ArchbaseAppContext: React.Context<ArchbaseAppContextValues>;
+interface ArchbaseAppProviderProps {
+    children?: ReactNode;
+    user: any | null;
+    owner: string | null;
+    selectedCompany: any | null;
+    iocContainer?: any;
+    dateFormat?: string;
+    dateTimeFormat?: string;
+    timeFormat?: string;
+    variant?: string;
+    languages?: ArchbaseLanguage[];
+    setCustomTheme?: (dark: MantineThemeOverride, light: MantineThemeOverride) => void;
+    navigationProvider?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+}
+declare const ArchbaseAppProvider: React.FC<ArchbaseAppProviderProps>;
+declare const useArchbaseAppContext: () => ArchbaseAppContextValues;
+export { ArchbaseAppContext, ArchbaseAppProvider, useArchbaseAppContext };
+export type { ArchbaseAppContextValues };

package/dist/context/ArchbaseGlobalProvider.d.ts

@@ -0,0 +1,33 @@
+import { MantineThemeOverride } from '@mantine/core';
+import { i18n, ResourceLanguage } from 'i18next';
+import React from 'react';
+import '../locales/config';
+type ArchbaseThemeOverride = MantineThemeOverride;
+interface ArchbaseTranslationResource {
+    [language: string]: ResourceLanguage;
+}
+interface ArchbaseAppProviderProps {
+    children?: React.ReactNode;
+    colorScheme: 'dark' | 'light';
+    containerIOC: any | undefined;
+    themeDark?: ArchbaseThemeOverride;
+    themeLight?: ArchbaseThemeOverride;
+    withCssVariables?: boolean;
+    notificationAutoClose?: number;
+    translationName?: string | string[];
+    translationResource?: ArchbaseTranslationResource;
+    notificationPosition?: 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
+}
+export declare const initArchbaseI18nEarly: (translationName: string | string[], translationResource: any) => void;
+export declare const initArchbaseTranslation: (translationName: any, translationResource: any) => Promise<any>;
+export declare const getI18nextInstance: () => i18n;
+export declare const archbaseI18next: i18n;
+export declare const useArchbaseTranslation: (namespace?: string) => {
+    t: (key: string, options?: any) => string | object;
+    i18n: i18n;
+    ready: boolean;
+};
+export declare const syncSafeTranslate: (key: string) => string;
+declare function ArchbaseGlobalProvider({ children, colorScheme, containerIOC, themeDark, themeLight, withCssVariables, notificationAutoClose, notificationPosition, translationName, translationResource, }: ArchbaseAppProviderProps): import("react/jsx-runtime").JSX.Element;
+export { ArchbaseGlobalProvider };
+export type { ArchbaseThemeOverride };

package/dist/context/ArchbaseSimpleAppContext.d.ts

@@ -0,0 +1,34 @@
+import React, { ReactNode } from 'react';
+export interface ArchbaseAppConfig {
+    /** URL base da API */
+    apiUrl?: string;
+    /** Locale padrão da aplicação */
+    locale?: string;
+    /** Tema da aplicação */
+    theme?: 'light' | 'dark' | 'auto';
+    /** Features flags */
+    features?: Record<string, boolean>;
+    /** Configurações de debug */
+    debug?: boolean;
+    /** Formato de data */
+    dateFormat?: string;
+    /** Formato de data e hora */
+    dateTimeFormat?: string;
+    /** Formato de hora */
+    timeFormat?: string;
+    /** Configurações customizadas */
+    custom?: Record<string, unknown>;
+}
+export interface ArchbaseAppContextValue {
+    config: ArchbaseAppConfig;
+    updateConfig: (updates: Partial<ArchbaseAppConfig>) => void;
+}
+declare const ArchbaseAppContext: React.Context<ArchbaseAppContextValue>;
+export interface ArchbaseAppProviderProps {
+    children: ReactNode;
+    config: ArchbaseAppConfig;
+    onConfigChange?: (config: ArchbaseAppConfig) => void;
+}
+export declare function ArchbaseAppProvider({ children, config: initialConfig, onConfigChange }: ArchbaseAppProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useArchbaseApp(): ArchbaseAppContextValue;
+export { ArchbaseAppContext };

package/dist/context/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ArchbaseSimpleAppContext';
+export { ArchbaseAppContext, ArchbaseAppProvider, useArchbaseAppContext } from './ArchbaseAppContext';
+export type { ArchbaseAppContextValues, ArchbaseLanguage } from './ArchbaseAppContext';
+export { ArchbaseGlobalProvider, initArchbaseTranslation, initArchbaseI18nEarly, syncSafeTranslate, getI18nextInstance, useArchbaseTranslation, archbaseI18next } from './ArchbaseGlobalProvider';
+export type { ArchbaseThemeOverride } from './ArchbaseGlobalProvider';

package/dist/error/ArchbaseError.d.ts

@@ -0,0 +1,14 @@
+export declare class ArchbaseError extends Error {
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly timestamp: Date;
+    constructor(message: string, code?: string, details?: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        details: unknown;
+        timestamp: Date;
+        stack: string;
+    };
+}

package/dist/error/index.d.ts

@@ -0,0 +1,11 @@
+export declare class ArchbaseError extends Error {
+    code?: string;
+    details?: unknown;
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ArchbaseDataSourceError extends ArchbaseError {
+    constructor(message: string, code?: string, details?: unknown);
+}
+export declare class ArchbaseServiceError extends ArchbaseError {
+    constructor(message: string, code?: string, details?: unknown);
+}

package/dist/errorboundary/ArchbaseErrorBoundary.d.ts

@@ -0,0 +1,21 @@
+import React, { Component, ErrorInfo } from 'react';
+import { ArchbaseErrorBoundaryProps } from './types';
+type ArchbaseErrorBoundaryState = {
+    didCatch: true;
+    error: any;
+} | {
+    didCatch: false;
+    error: null;
+};
+export declare class ArchbaseErrorBoundary extends Component<ArchbaseErrorBoundaryProps, ArchbaseErrorBoundaryState> {
+    constructor(props: ArchbaseErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        didCatch: boolean;
+        error: Error;
+    };
+    resetErrorBoundary(...args: any[]): void;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    componentDidUpdate(prevProps: ArchbaseErrorBoundaryProps, prevState: ArchbaseErrorBoundaryState): void;
+    render(): React.FunctionComponentElement<React.ProviderProps<import("./ArchbaseErrorBoundaryContext").ArchbaseErrorBoundaryContextType>>;
+}
+export {};

package/dist/errorboundary/ArchbaseErrorBoundaryContext.d.ts

@@ -0,0 +1,6 @@
+export type ArchbaseErrorBoundaryContextType = {
+    didCatch: boolean;
+    error: any;
+    resetErrorBoundary: (...args: any[]) => void;
+};
+export declare const ArchbaseErrorBoundaryContext: import("react").Context<ArchbaseErrorBoundaryContextType>;

package/dist/errorboundary/ArchbaseErrorFallback.d.ts

@@ -0,0 +1,7 @@
+import { PureComponent } from 'react';
+import { FallbackProps } from './types';
+export type ArchbaseErrorFallbackProps = FallbackProps;
+export declare class ArchbaseErrorFallback extends PureComponent<ArchbaseErrorFallbackProps> {
+    onClick(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/dist/errorboundary/assertArchbaseErrorBoundaryContext.d.ts

@@ -0,0 +1,2 @@
+import { ArchbaseErrorBoundaryContextType } from './ArchbaseErrorBoundaryContext';
+export declare function assertArchbaseErrorBoundaryContext(value: any): asserts value is ArchbaseErrorBoundaryContextType;

package/dist/errorboundary/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./ArchbaseErrorBoundary";
+export * from "./ArchbaseErrorBoundaryContext";
+export * from "./useArchbaseErrorBoundary";
+export * from "./withArchbaseErrorBoundary";
+export * from "./ArchbaseErrorFallback";
+export * from "./types";

package/dist/errorboundary/types.d.ts

@@ -0,0 +1,39 @@
+import { Component, ComponentType, ErrorInfo, FunctionComponent, PropsWithChildren, ReactElement, ReactNode } from "react";
+declare function FallbackRender(props: FallbackProps): ReactNode;
+export type FallbackProps = {
+    error: any;
+    resetErrorBoundary: (...args: any[]) => void;
+    othersProps?: any;
+};
+type ArchbaseErrorBoundarySharedProps = PropsWithChildren<{
+    onError?: (error: Error, info: ErrorInfo) => void;
+    onReset?: (details: {
+        reason: "imperative-api";
+        args: any[];
+    } | {
+        reason: "keys";
+        prev: any[] | undefined;
+        next: any[] | undefined;
+    }) => void;
+    resetKeys?: any[];
+}>;
+export type ArchbaseErrorBoundaryPropsWithComponent = ArchbaseErrorBoundarySharedProps & {
+    fallback?: never;
+    FallbackComponent: ComponentType<FallbackProps>;
+    fallbackRender?: never;
+    othersProps?: any;
+};
+export type ArchbaseErrorBoundaryPropsWithRender = ArchbaseErrorBoundarySharedProps & {
+    fallback?: never;
+    FallbackComponent?: never;
+    fallbackRender: typeof FallbackRender;
+    othersProps?: any;
+};
+export type ArchbaseErrorBoundaryPropsWithFallback = ArchbaseErrorBoundarySharedProps & {
+    fallback: ReactElement<unknown, string | FunctionComponent | typeof Component> | null;
+    FallbackComponent?: never;
+    fallbackRender?: never;
+    othersProps?: any;
+};
+export type ArchbaseErrorBoundaryProps = ArchbaseErrorBoundaryPropsWithFallback | ArchbaseErrorBoundaryPropsWithComponent | ArchbaseErrorBoundaryPropsWithRender;
+export {};

package/dist/errorboundary/useArchbaseErrorBoundary.d.ts

@@ -0,0 +1,5 @@
+export type UseArchbaseErrorBoundaryApi<TError> = {
+    resetBoundary: () => void;
+    showBoundary: (error: TError) => void;
+};
+export declare function useArchbaseErrorBoundary<TError = any>(): UseArchbaseErrorBoundaryApi<TError>;

package/dist/errorboundary/withArchbaseErrorBoundary.d.ts

@@ -0,0 +1,3 @@
+import { ComponentType } from 'react';
+import { ArchbaseErrorBoundaryProps } from './types';
+export declare function withArchbaseErrorBoundary<Props extends Object>(component: ComponentType<Props>, errorBoundaryProps: ArchbaseErrorBoundaryProps): any;

package/dist/exceptions/ApiError.d.ts

@@ -0,0 +1,27 @@
+export declare class ApiError {
+    private _status;
+    private _timestamp;
+    private _message;
+    private _debugMessage;
+    private _subErrors;
+    constructor(data: any);
+    get status(): number;
+    get timestamp(): Date;
+    get debugMessage(): string;
+    get message(): string;
+    get subErrors(): ApiSubError[];
+}
+export declare abstract class ApiSubError {
+    constructor();
+}
+export declare class ApiValidationError extends ApiSubError {
+    private _object;
+    private _field;
+    private _rejectedValue;
+    private _message;
+    constructor(data: any);
+    get object(): string;
+    get field(): string;
+    get rejectedValue(): any;
+    get message(): string;
+}

package/dist/exceptions/ArchbaseErrorHelper.d.ts

@@ -0,0 +1,2 @@
+export declare function processErrorMessage(error: any): string;
+export declare function processDetailErrorMessage(error: any): string;

package/dist/exceptions/ArchbaseException.d.ts

@@ -0,0 +1,9 @@
+export declare class ArchbaseError extends Error {
+    constructor(message: any);
+}
+export declare class ArchbaseServiceError extends Error {
+    constructor(message: any);
+}
+export declare class ArchbaseDataSourceError extends Error {
+    constructor(message: any);
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1,3 @@
+export { processDetailErrorMessage, processErrorMessage } from './ArchbaseErrorHelper';
+export { ArchbaseDataSourceError, ArchbaseError, ArchbaseServiceError } from './ArchbaseException';
+export { ApiError, ApiSubError, ApiValidationError } from './ApiError';

package/dist/fallback/ArchbaseSafeMigrationWrapper.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ArchbaseSafeMigrationWrapper
+ *
+ * Sistema de fallback seguro para migração V1/V2.
+ * Garante que se V2 falhar, automaticamente volta para V1.
+ *
+ * ⚠️ CRITICAL: Este wrapper é obrigatório para todos os componentes migrados.
+ */
+import React, { Component, ErrorInfo, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallbackComponent: React.ComponentType<any>;
+    componentName: string;
+    v2Props: any;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface State {
+    hasError: boolean;
+    error?: Error;
+    fallbackActive: boolean;
+}
+/**
+ * Error Boundary que implementa fallback automático V2 → V1
+ */
+export declare class ArchbaseSafeMigrationWrapper extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode>>;
+}
+/**
+ * Hook para criar wrapper de migração segura
+ */
+export declare function useArchbaseSafeMigration<TProps>(componentName: string, V1Component: React.ComponentType<TProps>, V2Component: React.ComponentType<TProps>): {
+    (props: TProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * HOC para aplicar migração segura
+ */
+export declare function withSafeMigration<TProps>(componentName: string, V1Component: React.ComponentType<TProps>, V2Component: React.ComponentType<TProps>): {
+    (props: TProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+/**
+ * Utilitário para detectar versão do DataSource
+ */
+export declare function detectDataSourceVersion(dataSource: any): 'V1' | 'V2' | 'NONE';
+/**
+ * Métricas para monitoramento de migração
+ */
+export declare const MigrationMetrics: {
+    trackV2Usage: (componentName: string, dataSourceVersion: string) => void;
+    trackFallback: (componentName: string, reason: string) => void;
+    trackError: (componentName: string, error: Error) => void;
+};
+export default ArchbaseSafeMigrationWrapper;

package/dist/helper/ArchbaseClickOutside.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+interface ArchbaseClickOutsideProps {
+    children: ReactNode;
+    exceptionRef?: any;
+    onClick: (event: MouseEvent) => void;
+    className?: string;
+}
+export declare function ArchbaseClickOutside({ children, exceptionRef, onClick, className }: ArchbaseClickOutsideProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/helper/ArchbaseObjectHelper.d.ts

@@ -0,0 +1,9 @@
+declare class ArchbaseObjectHelper {
+    getNestedProperty(object: any, property: any): any;
+    hasNestedProperty(object: any, property: any, options: any): any;
+    setNestedProperty(object: any, property: any, value: any): any;
+    isInNestedProperty(object: any, property: any, objectInPath: any, options: any): boolean;
+    isEmpty(obj: any): boolean;
+}
+declare const instance: ArchbaseObjectHelper;
+export { instance as ArchbaseObjectHelper };

package/dist/helper/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseObjectHelper } from './ArchbaseObjectHelper';
+export { ArchbaseClickOutside } from './ArchbaseClickOutside';

package/dist/hooks/ArchbaseDepencyManager.d.ts

@@ -0,0 +1,70 @@
+/**
+ * # ArchbaseDependencyProvider Component
+ *
+ * O `ArchbaseDependencyProvider` é um componente React que facilita a comunicação entre componentes em uma aplicação,
+ * permitindo que se registrem como ouvintes de dependências específicas e sejam notificados sobre atualizações,
+ * acompanhadas de dados relevantes.
+ *
+ * ## Uso
+ *
+ * Para utilizar, envolva os componentes com `ArchbaseDependencyProvider`. Dentro dos componentes filhos,
+ * utilize o hook `useArchbaseDependency` para registrar ouvintes para dependências específicas ou para notificar
+ * sobre atualizações de dependências.
+ *
+ * ## Exemplo
+ *
+ * ```jsx
+ * import React from 'react';
+ * import { ArchbaseDependencyProvider, useArchbaseDependency } from './ArchbaseDependencyManager';
+ *
+ * const App = () => (
+ *   <ArchbaseDependencyProvider>
+ *     <ChildComponent />
+ *     <SiblingComponent />
+ *   </ArchbaseDependencyProvider>
+ * );
+ *
+ * const ChildComponent = () => {
+ *   const { registerListener } = useArchbaseDependency();
+ *
+ *   useEffect(() => {
+ *     const handleDataChange = (newData, extra) => {
+ *       console.log('Data updated:', newData, 'Additional info:', extra);
+ *     };
+ *
+ *     registerListener('key', handleDataChange);
+ *   }, []);
+ *
+ *   return <div>Child Component</div>;
+ * };
+ *
+ * const SiblingComponent = () => {
+ *   const { enqueueUpdate } = useArchbaseDependency();
+ *
+ *   const updateData = () => {
+ *     enqueueUpdate('key', 'updatedValue', { extraData: 'extraInfo' });
+ *   };
+ *
+ *   return <button onClick={updateData}>Update Data</button>;
+ * };
+ * ```
+ *
+ * Este exemplo mostra como `SiblingComponent` pode notificar `ChildComponent` sobre atualizações,
+ * usando o `ArchbaseDependencyProvider` para gerenciar a dependência 'key' entre eles.
+ */
+import React, { ReactNode } from 'react';
+type UpdateQueueItem = {
+    key: string;
+    value: any;
+    data: any;
+};
+interface ArchbaseDependencyProviderProps {
+    children: ReactNode;
+}
+export declare const ArchbaseDependencyProvider: React.FC<ArchbaseDependencyProviderProps>;
+export declare const useArchbaseDependency: () => {
+    registerListener: (key: string, listener: Function) => void;
+    removeListener: (key: string, listener: Function) => void;
+    enqueueUpdate: (update: UpdateQueueItem) => void;
+};
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from './useArchbaseTheme';
+export * from './useArchbaseSize';
+export * from './useArchbaseBool';
+export * from './useArchbasePasswordRemember';
+export * from './useArchbaseValidator';
+export * from './useArchbaseAsyncFunction';
+export * from './useArchbaseForceRenderer';
+export * from './useArchbaseLatest';
+export * from './useArchbasePassiveLayoutEffect';
+export * from './useArchbaseReducer';
+export * from './useArchbaseStateWithCallback';
+export * from './useArchbaseResizeObserver';
+export * from './useArchbaseTextSelection';
+export * from './ArchbaseDepencyManager';
+export * from './lifecycle';

package/dist/hooks/lifecycle/index.d.ts

@@ -0,0 +1,54 @@
+import type { DependencyList, EffectCallback, FC } from 'react';
+type Props = Record<string, unknown>;
+type ShouldComponentUpdateHandler = (props: Props, nextProps: Props) => boolean;
+/**
+ * Called immediately before mounting occurs ( before render the component).
+ * Avoid introducing any side-effects or subscriptions in this method.
+ * Please, see our docs dir for this hook. Be Careful.
+ *
+ * @param handler callback function only allowed to return void.
+ */
+declare function useArchbaseWillMount(handler: EffectCallback): void;
+/**
+ * Called immediately after a component is mounted.
+ * Setting state here will trigger re-rendering.
+ *
+ * @param handler callback function only allowed to return void.
+ */
+declare function useArchbaseDidMount(handler: EffectCallback): void;
+/**
+ * Called immediately after updating occurs.
+ * Note : Called for the initial render.
+ *
+ * @param handler callback function only allowed to return void.
+ */
+declare function useArchbaseDidUpdate(handler: EffectCallback, deps?: DependencyList): void;
+/**
+ * Behave like shouldComponentUpdate but with different params.
+ *
+ * @param Component component want to inject with the shouldComponentUpdate lifecycle.
+ * @param shouldComponentUpdateHandler comparator like the shouldComponentUpdate lifecycle.
+ * @returns [PureComponent]
+ */
+declare function useShouldComponentUpdate(Component: FC, shouldComponentUpdateHandler?: ShouldComponentUpdateHandler): import("react").NamedExoticComponent<{}>[];
+/**
+ * @alias useShouldComponentUpdate
+ */
+declare function usePureComponent(Component: FC, shouldComponentUpdateHandler?: ShouldComponentUpdateHandler): import("react").NamedExoticComponent<{}>[];
+/**
+ * @alias useShouldComponentUpdate but with diffrent pattern (HOC)!
+ */
+declare function withShouldComponentUpdate(Component: FC): (shouldComponentUpdateHandler: ShouldComponentUpdateHandler) => import("react").NamedExoticComponent<{}>;
+/**
+ * Called immediately before a component is destroyed.
+ * Perform any necessary cleanup in this method, such
+ * as cancelled network requests, or cleaning up any
+ * DOM elements created in `useArchbaseDidMount`.
+ *
+ * @param handler callback function only allowed to return void.
+ */
+declare function useArchbaseWillUnmount(handler: () => void): void;
+declare function useArchbasePrevious(value: any): any;
+declare const useArchbaseIsMounted: () => boolean;
+declare const useArchbaseForceUpdate: () => () => void;
+export { useArchbaseDidMount, useArchbaseDidUpdate, useArchbaseForceUpdate, useArchbaseIsMounted, useArchbasePrevious, useArchbaseWillMount, useArchbaseWillUnmount, usePureComponent, useShouldComponentUpdate, withShouldComponentUpdate };

package/dist/hooks/useArchbaseAsyncFunction.d.ts

@@ -0,0 +1 @@
+export declare function useArchbaseAsyncFunction<T>(asyncFunction: () => Promise<T>, defaultValue: T): [T, string | null, boolean];

package/dist/hooks/useArchbaseBool.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook para gerenciar estado booleano com funções helper
+ * @param initialValue Valor inicial (padrão: false)
+ * @returns [valor, setTrue, setFalse, toggle]
+ */
+export declare function useArchbaseBool(initialValue?: boolean): readonly [boolean, () => void, () => void, () => void];

package/dist/hooks/useArchbaseForceRenderer.d.ts

@@ -0,0 +1 @@
+export declare const useArchbaseForceRerender: () => (() => void);

package/dist/hooks/useArchbaseLatest.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const useArchbaseLatest: <T extends unknown>(current: T) => React.RefObject<T>;
+export default useArchbaseLatest;

package/dist/hooks/useArchbasePassiveLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const useArchbasePassiveLayoutEffect: typeof React.useEffect | typeof React.useLayoutEffect;
+export default useArchbasePassiveLayoutEffect;

package/dist/hooks/useArchbasePasswordRemember.d.ts

@@ -0,0 +1,11 @@
+export declare function useArchbasePasswordRemember(): {
+    rememberMe: boolean;
+    clearRememberMe: () => void;
+    username: string;
+    password: string;
+    setRememberMe: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setUsername: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setPassword: import("react").Dispatch<import("react").SetStateAction<string>>;
+    saveCredentials: (user: string, pass: string, remember: boolean) => void;
+    clearCredentials: () => void;
+};

package/dist/hooks/useArchbaseReducer.d.ts

@@ -0,0 +1,21 @@
+export interface ArchbaseStore {
+    setValue: (key: string, value: any) => void;
+    getValue: (key: string) => any;
+    existsValue: (key: string) => boolean;
+    clearValue: (key: string) => void;
+    clearAllValues: () => void;
+    reset: () => void;
+    values: Map<string, any>;
+}
+export interface ArchbaseState {
+}
+export type ArchbaseReducerAction<ArchbaseState> = {
+    type: string;
+    payload: Partial<ArchbaseState>;
+    info?: string;
+};
+export type ArchbaseReducer<S extends ArchbaseState, A extends ArchbaseReducerAction<S>> = (state: S, action: A) => S;
+export declare function useArchbaseReducer<S extends ArchbaseState, A extends ArchbaseReducerAction<S>>(key: string, store: ArchbaseStore, initialState: S, customReducer: ArchbaseReducer<S, A>): {
+    dispatch: (action: A) => void;
+    state: S;
+};

package/dist/hooks/useArchbaseResizeObserver.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { ResizeObserver as Polyfill, ResizeObserverEntry } from '@juggle/resize-observer';
+/**
+ * A React hook that fires a callback whenever ResizeObserver detects a change to its size
+ *
+ * @param target A React ref created by `useRef()` or an HTML element
+ * @param callback Invoked with a single `ResizeObserverEntry` any time
+ *   the `target` resizes
+ */
+export declare function useArchbaseResizeObserver<T extends HTMLElement>(target: React.RefObject<T> | T | null, callback: UseResizeObserverCallback): Polyfill;
+export type UseResizeObserverCallback = (entry: ResizeObserverEntry, observer: Polyfill) => any;