@gaddario98/react-core 2.0.2 → 2.0.3

package/dist/form/index.d.ts

@@ -0,0 +1,236 @@
+import * as _gaddario98_react_state from '@gaddario98/react-state';
+import * as React$1 from 'react';
+import React__default, { PropsWithChildren, JSX } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _tanstack_react_form from '@tanstack/react-form';
+import { FormOptions, DeepKeys, DeepValue, FieldApi, FieldState, ReactFormExtendedApi } from '@tanstack/react-form';
+import * as jotai from 'jotai';
+
+interface FormNotificationMessage {
+    message: string;
+    type: 'success' | 'error' | 'info' | 'warning';
+    autoHideDuration?: number;
+    textTransOption?: Record<string, unknown>;
+    ns?: string;
+}
+interface FormTranslationOptions {
+    [key: string]: string | number | boolean | undefined;
+    ns?: string;
+}
+interface FormConfigProps {
+    formFieldContainer: React.FC<PropsWithChildren>;
+    showNotification?: (notification: FormNotificationMessage) => void;
+    translateText?: (key: string, options?: FormTranslationOptions) => string;
+}
+declare const formConfigAtom: _gaddario98_react_state.PrimitiveAtom<FormConfigProps>;
+declare const useFormConfigValue: () => FormConfigProps;
+declare const useFormConfigState: () => [FormConfigProps, (value: FormConfigProps) => void];
+declare const useFormConfigReset: () => () => void;
+
+interface UseCustomFormOptions<TData extends FieldValues> extends FormOptions<TData, any, any, any, any, any, any, any, any, any, any, any> {
+    formId?: string;
+}
+declare function useJotaiForm<TData extends FieldValues>(formOptions: UseCustomFormOptions<TData>): _tanstack_react_form.ReactFormExtendedApi<TData, any, any, any, any, any, any, any, any, any, any, any>;
+
+interface FormElements {
+    index: number;
+    element: JSX.Element;
+    renderInFooter: boolean;
+    renderInHeader: boolean;
+    isSubmit?: boolean;
+}
+declare const useFormManager: <F extends FieldValues = FieldValues>({ data, onInvalid, submit, notification, formOptions, onValuesChange, globalErrorNs, id, }: UseFormManagerProps<F>) => {
+    elements: FormElements[];
+    formContents: (FormManagerConfig<F> | ((props: FormFunctionProps<F>) => FormManagerConfig<F>) | Submit<F, SubmitKeysArg<F>>)[];
+    errors: any[];
+    formValues: F;
+    setValue: SetValueFunction<F>;
+};
+
+interface UseFormValuesProps {
+    formId: string;
+    scopeId?: string;
+}
+declare const useFormValues: <F extends FieldValues>({ formId, }: UseFormValuesProps) => FormFunctionProps<F>;
+
+type FieldValues = Record<string, any>;
+type SetValueFunction<F extends FieldValues> = <TField extends DeepKeys<F>>(field: TField, value: DeepValue<F, TField>) => void;
+type GetFormValuesFunction<F extends FieldValues> = {
+    <TField extends DeepKeys<F>>(key: TField): DeepValue<F, TField> | undefined;
+    <TField extends DeepKeys<F>>(key: TField, defaultValue: DeepValue<F, TField>): NonNullable<DeepValue<F, TField>>;
+};
+type GenericFormApi<TData extends FieldValues> = ReactFormExtendedApi<TData, any, any, any, any, any, any, any, any, any, any, any>;
+type GenericFieldApi<TData extends FieldValues> = FieldApi<TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type GenericFieldState<TData extends FieldValues> = FieldState<TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type SubmitKeysArg<T> = ReadonlyArray<keyof T> | undefined;
+type SubmitPayload<T, K extends SubmitKeysArg<T>> = K extends ReadonlyArray<keyof T> ? Pick<T, K[number]> : T;
+type FormFunctionProps<F extends FieldValues> = {
+    get: GetFormValuesFunction<F>;
+    set: SetValueFunction<F>;
+};
+interface Submit<T extends FieldValues = FieldValues, K extends SubmitKeysArg<T> = SubmitKeysArg<T>> {
+    onSuccess?: (values: T) => void;
+    onError?: (err: Error) => void;
+    values?: K;
+    index?: number;
+    buttonProps?: Record<string, unknown>;
+    renderInFooter?: boolean;
+    hidden?: boolean;
+    renderInHeader?: boolean;
+    isDisabled?: boolean;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    isLoading?: boolean;
+    usedBoxes?: number;
+    type?: 'submit' | 'button';
+    key?: string;
+    component?: (props: {
+        onClick: () => void;
+        index: number;
+        key: string;
+        type: 'submit' | 'button';
+    }) => React__default.JSX.Element;
+}
+interface ViewSettingsContainerProps {
+    children: React__default.ReactNode;
+}
+type FormManagerProps<T extends FieldValues = FieldValues> = {
+    data: Array<FormManagerConfig<T> | ((props: FormFunctionProps<T>) => FormManagerConfig<T>)>;
+    defaultValues: T;
+    onInvalid?: (err: unknown) => void;
+    isHiddenErrors?: boolean;
+    ns?: string;
+    globalErrorNs?: string;
+    submit?: Array<Submit<T>>;
+    notification?: {
+        success?: FormNotificationMessage | ((res: unknown) => FormNotificationMessage);
+        error?: FormNotificationMessage | ((error: string) => FormNotificationMessage);
+        ns?: string;
+    };
+    onValuesChange?: (props: T, setValue: (name: any, value: any) => void) => void;
+    formSettings?: UseCustomFormOptions<T>;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    id?: string;
+    viewSettings?: {
+        container?: React__default.ComponentType<ViewSettingsContainerProps>;
+        submitContainer?: React__default.ComponentType<ViewSettingsContainerProps>;
+        bodyContainer?: React__default.ComponentType<ViewSettingsContainerProps>;
+        containerProps?: Record<string, unknown>;
+        submitContainerProps?: Record<string, unknown>;
+        bodyContainerProps?: Record<string, unknown>;
+    };
+};
+type UseFormManagerProps<T extends FieldValues> = {
+    data: Array<FormManagerConfig<T> | ((props: FormFunctionProps<T>) => FormManagerConfig<T>)>;
+    onInvalid?: (err: unknown) => void;
+    formOptions: UseCustomFormOptions<T>;
+    isHiddenErrors?: boolean;
+    ns?: string;
+    globalErrorNs?: string;
+    submit?: Array<Submit<T>>;
+    notification?: {
+        success?: FormNotificationMessage | ((res: unknown) => FormNotificationMessage);
+        error?: FormNotificationMessage | ((error: string) => FormNotificationMessage);
+        ns?: string;
+    };
+    onValuesChange?: (props: T, setValue: (name: any, value: any) => void) => void;
+    id?: string;
+};
+interface FieldComponentProps<T extends FieldValues> {
+    value: any;
+    onChange: (value: any) => void;
+    onBlur: () => void;
+    error?: boolean;
+    errorMessage?: string;
+    formValues?: T;
+    label?: string;
+    helperMessage?: string;
+}
+type FormManagerConfig<T extends FieldValues> = Omit<FormFieldConfig<T>, 'field' | 'fieldState' | 'fieldValues'>;
+type MappedFormItemsFunction<F extends FieldValues, ComponentType> = (props: FormFunctionProps<F>) => ComponentType;
+type Rules = {
+    validate?: (value: any) => string | undefined | Promise<string | undefined>;
+    onChange?: (value: any) => void;
+    onBlur?: () => void;
+    onMount?: (value: any) => void;
+};
+type FormFieldConfig<T extends FieldValues> = {
+    name: any;
+    label?: string;
+    rules?: Rules | MappedFormItemsFunction<T, Rules>;
+    field: GenericFieldApi<T>;
+    fieldState: GenericFieldState<T>;
+    containerStyle?: string;
+    component: (props: Omit<FieldComponentProps<T>, 'formValues'>) => React__default.JSX.Element;
+    container?: React__default.FC<PropsWithChildren>;
+    ns?: string;
+    errorNs?: string;
+    index?: number;
+    renderInFooter?: boolean;
+    renderInHeader?: boolean;
+    usedBoxes?: number;
+    key?: string;
+    isDraggable?: boolean;
+    isInDraggableView?: boolean;
+    helper?: {
+        text?: string;
+        translationOption?: FormTranslationOptions;
+    };
+    onFieldChange?: (value: any) => void;
+    hidden?: boolean | MappedFormItemsFunction<T, boolean>;
+};
+interface ErrorComponentProps {
+    message?: string;
+    fieldName?: string;
+}
+interface FormContainerProps {
+    className?: string;
+    children: React__default.ReactNode;
+}
+interface FormFieldProps<T extends FieldValues> {
+    config: FormFieldConfig<T>;
+    onFieldChange?: (value: T) => void;
+    ns?: string;
+    globalErrorNs?: string;
+    container?: React__default.FC<PropsWithChildren>;
+}
+
+interface DefaultFormContainerProps {
+    children: React.ReactNode;
+}
+declare let DefaultContainer: ({ children }: ViewSettingsContainerProps) => React$1.ReactNode;
+declare const setDefaultFormContainer: (val: ({ children, }: ViewSettingsContainerProps) => React.ReactNode) => void;
+declare const DefaultFormContainer: <_T extends FieldValues = FieldValues>({ children, }: ViewSettingsContainerProps) => react_jsx_runtime.JSX.Element;
+
+declare const FormManager: <T extends Record<string, any> = FieldValues>({ data, defaultValues, onInvalid, submit, ns, globalErrorNs, notification, formSettings, viewSettings, onValuesChange, id, }: FormManagerProps<T>) => react_jsx_runtime.JSX.Element;
+
+declare const FormField: <T extends FieldValues>({ config, onFieldChange, ns: globalNs, globalErrorNs, }: FormFieldProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface FormStoreEntry<F extends FieldValues = FieldValues> {
+    formValues: F;
+    setValue: SetValueFunction<F>;
+}
+declare const DEFAULT_FORM_ENTRY: FormStoreEntry<FieldValues>;
+/**
+ * Global atom storing all form state.
+ * Key format: "scopeId:formId" or just "formId" for backward compatibility.
+ */
+declare const formAtom: jotai.PrimitiveAtom<Record<string, FormStoreEntry<FieldValues>>> & {
+    init: Record<string, FormStoreEntry<FieldValues>>;
+};
+/**
+ * Helper to generate composite keys for forms.
+ */
+declare const getFormCompositeKey: (scopeId: string, key: string) => string;
+/**
+ * Creates a derived atom for accessing forms of a specific scope.
+ */
+declare const createScopeFormsAtom: (scopeId: string) => jotai.WritableAtom<Record<string, FormStoreEntry<FieldValues>>, [update: Record<string, FormStoreEntry<FieldValues>>], void>;
+declare const createFormSelector: <F extends FieldValues = FieldValues>(formId: string) => jotai.Atom<FormStoreEntry<F>>;
+declare const useFormValue: <F extends FieldValues>(formId: string) => FormStoreEntry<F>;
+declare const useFormState: <F extends FieldValues>() => [Record<string, FormStoreEntry<F>>, (value: Record<string, FormStoreEntry<F>>) => void];
+declare const useSetFormState: <F extends FieldValues>(formId: string) => (val: Partial<FormStoreEntry<F>>) => void;
+
+export { DEFAULT_FORM_ENTRY, DefaultContainer, DefaultFormContainer, FormField, FormManager, createFormSelector, createScopeFormsAtom, formAtom, formConfigAtom, getFormCompositeKey, setDefaultFormContainer, useFormConfigReset, useFormConfigState, useFormConfigValue, useFormManager, useFormState, useFormValue, useFormValues, useJotaiForm, useSetFormState };
+export type { DefaultFormContainerProps, ErrorComponentProps, FieldComponentProps, FieldValues, FormConfigProps, FormContainerProps, FormElements, FormFieldConfig, FormFieldProps, FormFunctionProps, FormManagerConfig, FormManagerProps, FormNotificationMessage, FormStoreEntry, FormTranslationOptions, GenericFieldApi, GenericFieldState, GenericFormApi, GetFormValuesFunction, MappedFormItemsFunction, Rules, SetValueFunction, Submit, SubmitKeysArg, SubmitPayload, UseCustomFormOptions, UseFormManagerProps, UseFormValuesProps, ViewSettingsContainerProps };

package/dist/localization/index.d.ts

@@ -0,0 +1,155 @@
+import * as _gaddario98_react_state from '@gaddario98/react-state';
+
+type Locale = string;
+type TranslationResources = Record<string, any>;
+/**
+ * Opzioni di formattazione per i diversi tipi di valori
+ */
+interface FormatOptions {
+    number?: Intl.NumberFormatOptions;
+    date?: Intl.DateTimeFormatOptions;
+    currency?: Intl.NumberFormatOptions & {
+        currency?: string;
+    };
+}
+/**
+ * Opzioni per la traduzione con supporto parametri avanzati
+ */
+interface TranslationOptions {
+    [key: string]: any;
+    defaultValue?: string;
+    /**
+     * Opzioni di formattazione per i parametri specifici
+     *
+     * @example
+     * ```ts
+     * t('welcome', {
+     *   price: 1234.56,
+     *   formatOptions: {
+     *     price: {
+     *       currency: { currency: 'EUR', minimumFractionDigits: 2 }
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    formatOptions?: Record<string, FormatOptions>;
+    ns?: string;
+}
+/**
+ * Funzione di traduzione con supporto parametri avanzati
+ *
+ * @example Interpolazione semplice
+ * ```ts
+ * t('welcome', { name: 'Mario' })
+ * // "Benvenuto {{name}}" -> "Benvenuto Mario"
+ * ```
+ *
+ * @example Formattazione numeri
+ * ```ts
+ * t('items_count', { count: 1000 })
+ * // "Hai {{count, number}} elementi" -> "Hai 1,000 elementi"
+ * ```
+ *
+ * @example Formattazione date
+ * ```ts
+ * t('last_login', { date: new Date() })
+ * // "Ultimo accesso: {{date, date}}" -> "Ultimo accesso: 15/12/2025"
+ * ```
+ *
+ * @example Formattazione valuta
+ * ```ts
+ * t('total', {
+ *   price: 99.99,
+ *   formatOptions: {
+ *     price: { currency: { currency: 'EUR' } }
+ *   }
+ * })
+ * // "Totale: {{price, currency}}" -> "Totale: €99.99"
+ * ```
+ *
+ * @example Pluralizzazione
+ * ```ts
+ * t('items', { count: 0 })
+ * // "{{count, plural, =0{Nessun elemento} one{Un elemento} other{# elementi}}}"
+ * // -> "Nessun elemento"
+ *
+ * t('items', { count: 1 })
+ * // -> "Un elemento"
+ *
+ * t('items', { count: 5 })
+ * // -> "5 elementi"
+ * ```
+ *
+ * @example Selezione
+ * ```ts
+ * t('greeting', { gender: 'male' })
+ * // "{{gender, select, male{Benvenuto} female{Benvenuta} other{Benvenuto/a}}}"
+ * // -> "Benvenuto"
+ * ```
+ */
+type TranslateFunction = (key: string, options?: TranslationOptions) => string;
+interface I18nConfig {
+    defaultLocale: Locale;
+    supportedLocales: Array<Locale>;
+}
+
+interface LocalizationConfigProps {
+    currentLocale: Locale;
+    locales: Record<Locale, TranslationResources>;
+}
+declare const localizationConfigAtom: _gaddario98_react_state.PrimitiveAtom<LocalizationConfigProps>;
+declare const useLocalizationConfigValue: () => LocalizationConfigProps;
+declare const useLocalizationConfigState: () => [LocalizationConfigProps, (value: LocalizationConfigProps) => void];
+declare const useLocalizationConfigReset: () => () => void;
+/**
+ * Hook per gestire le operazioni di localization
+ */
+declare const useLocalizationActions: () => {
+    /**
+     * Aggiunge o aggiorna una locale con le sue risorse
+     */
+    addLocale: (locale: Locale, resources: TranslationResources) => void;
+    /**
+     * Switch alla locale specificata
+     */
+    switchLocale: (locale: Locale) => void;
+    /**
+     * Inizializza con una locale di default
+     */
+    initializeLocale: (locale: Locale, resources: TranslationResources) => void;
+};
+
+/**
+ * Funzione core per risolvere una traduzione.
+ */
+declare const resolveTranslation: (key: string, resources: TranslationResources, options?: TranslationOptions, locale?: string) => string;
+
+declare const useTranslation: (_ns?: string) => {
+    t: TranslateFunction;
+    locale: Locale;
+};
+
+/**
+ * Crea un'istanza di traduzione per l'uso lato server (o fuori dai componenti React).
+ */
+declare const createServerTranslator: (resources: TranslationResources, locale?: Locale) => {
+    t: TranslateFunction;
+    locale: Locale;
+};
+
+type TranslationFunction = (key: string, options?: TranslationOptions) => string;
+/**
+ * Hook per tradurre testi che si adatta al sistema di traduzione interno.
+ * Wrapper di retro-compatibilità per useTranslation.
+ *
+ * @param ns - Namespace opzionale (ignorato nella nuova implementazione)
+ * @returns Un oggetto con la funzione traslateText (e alias t)
+ */
+declare const useTranslatedText: (ns?: string) => {
+    traslateText: (text: string, options?: TranslationOptions) => string;
+    t: (text: string, options?: TranslationOptions) => string;
+};
+
+export { createServerTranslator, localizationConfigAtom, resolveTranslation, useLocalizationActions, useLocalizationConfigReset, useLocalizationConfigState, useLocalizationConfigValue, useTranslatedText, useTranslation };
+export type { FormatOptions, I18nConfig, Locale, LocalizationConfigProps, TranslateFunction, TranslationFunction, TranslationOptions, TranslationResources };

package/dist/notifications/index.d.ts

@@ -0,0 +1,37 @@
+import * as _gaddario98_react_state from '@gaddario98/react-state';
+
+interface NotificationMessage {
+    id: string;
+    message: string;
+    type: 'success' | 'error' | 'info' | 'warning';
+    autoHideDuration?: number;
+    textTransOption?: Record<string, unknown>;
+    ns?: string;
+}
+type TypeNotification = 'like' | 'message' | 'comments' | 'follow';
+interface UserNotification {
+    uid: string;
+    type: TypeNotification;
+    postId?: string;
+    typePost?: string;
+    token: string;
+    message?: string;
+    data?: Date;
+    read: boolean;
+    notificationId: string;
+    nickname?: string;
+    titlePost?: string;
+}
+type NotificationConfig = Partial<Omit<NotificationMessage, 'id'>>;
+
+declare const useNotification: (ns?: string) => {
+    showNotification: (notification: Omit<NotificationMessage, "id">) => void;
+    clearNotification: () => void;
+};
+
+declare const notificationAtom: _gaddario98_react_state.PrimitiveAtom<NotificationMessage | null>;
+declare const useNotificationValue: () => NotificationMessage | null;
+declare const useNotificationState: () => [NotificationMessage | null, (value: NotificationMessage | null) => void];
+
+export { notificationAtom, useNotification, useNotificationState, useNotificationValue };
+export type { NotificationConfig, NotificationMessage, UserNotification };