@dxtmisha/functional 1.13.4 → 1.13.7

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.13.7] - 2026-06-19
+
+### Added
+- **GeoRef**: Added static reactive `getLocation()`, `getLocationCountry()`, and `getLocationLanguage()` methods returning isolated `ComputedRef<string>` representations of location components.
+
+### Fixed
+- **Tests**: Adjusted test assertions in `GeoRef.test.ts` for `'en-VN'` to expect country `'VN'` and standard `'en-VN'` under the country-first matching priority.
+
+## [1.13.5] - 2026-06-17
+
+
+### Changed / Improved
+- **GeoRef**: Refactored static getters (`getCountry`, `getLanguage`, `getStandard`, `getFirstDay`) to use request-isolated computed references via `ServerStorage.get`. This isolates their reactive state per request, resolving potential cross-request state pollution during SSR.
+
 ## [1.13.4] - 2026-06-17
 
 ### Added

package/ai-description.md

@@ -0,0 +1,18 @@
+Core Purpose: A high-level reactive framework for Vue 3 that abstracts complex state, API orchestration, and UI design patterns. It provides a standardized layer for API management (including SSR support), data formatting, list manipulation, and design component architecture.
+
+Key Expositions:
+1. API Management: `useApiRef` (standard reactive fetch), `useApiManagementRef` (orchestrates GET/POST/PUT/DELETE with search/formatting), and SSR-specific versions (`useApiAsyncRef`, `useApiManagementAsyncRef`).
+2. Design System Components: `DesignConstructorAbstract` and `DesignComponents` for building reactive, theme-aware components; `DesignChanged` for tracking property mutations.
+3. Geo/Intl Utilities: `GeoIntlRef` (localized formatting for numbers, dates, currency, size), `GeoRef` (locale/country state management), and `GeoFlagRef`.
+4. Reactive Ref Utilities: `ListDataRef` (complex list management, grouping, selection, navigation), `EventRef` (reactive event listeners), and various composables for `localStorage`/`sessionStorage`/`cookies`.
+5. Functional Helpers: `executeUse` (singleton management: global/provide/local), `computedAsync`/`computedEternity` (advanced reactivity wrappers).
+
+Triggers for Studying ai-types.md:
+- When implementing or consuming API requests with `useApi...` hooks to understand data contracts and error handling.
+- When configuring `executeUse` strategies (global vs provide) for service injection.
+- When defining component properties or structures using `Constr...` types (e.g., `ConstrBind`, `ConstrOptions`).
+- When managing complex lists or search logic requiring `ListDataRef` or `Search...` types.
+- When creating custom design classes inheriting from `DesignConstructorAbstract`.
+
+Integration Context: 
+This library serves as a middleware layer between raw API responses/browser APIs and Vue components. It is designed to work with `@dxtmisha/functional-basic` (the core utility provider) and relies on Vue's reactivity system. It is meant to be registered as a plugin (`dxtFunctionalPlugin`) to provide global configurations for API clients, translation services, and routing.

package/ai-doc.md

@@ -0,0 +1,226 @@
+This is the main functional library for the Vue environment (@dxtmisha/functional). It contains Vue-specific utilities, composables, and reactive classes.
+
+USAGE RULES:
+1. When developing in Vue, always use this library for functionality, logic, and composables instead of `@dxtmisha/functional-basic` whenever possible.
+2. It wraps basic non-reactive logic into Vue's reactivity system. If the required function or composable exists here, it has absolute priority.
+3. Import utilities from `@dxtmisha/functional` for reactive UI behavior, composables, and state management.
+
+WORKING WITH API AND STATE (useApi / executeUse):
+A set of composables is provided for network requests: `useApiGet`, `useApiPost`, `useApiPut`, `useApiDelete`, `useApiRequest`, `useApiRef`, `useApiAsyncRef`, `useApiManagementRef`, `useApiManagementAsyncRef`.
+Strictly follow these rules for their application:
+
+1. DO NOT call these composables directly in the Vue components (SFC).
+2. Move all API configurations and `useApi*` calls into SEPARATE FILES (services/stores).
+3. Wrap the API configurations inside the `executeUse` factory (specifically: `executeUseGlobal`, `executeUseProvide`, or `executeUseLocal` from `src/functions/executeUse.ts`). This guarantees the creation of managed singletons (single access point) and prevents duplicated requests and reactive states.
+4. Perform any additional request processing (e.g., data mapping, preparing structures for skeletons before loading a form) in the same file, inside the `executeUse` callback, and return a fully prepared set of data and methods.
+   *Example of correct usage:*
+   ```ts
+   import { executeUseGlobal } from '@dxtmisha/functional';
+   import { useApiManagementRef } from '@dxtmisha/functional';
+
+   export const useUserManagement = executeUseGlobal(() => {
+     return useApiManagementRef(
+       { path: '/api/users' },                 // GET setup
+       { date: (v) => new Date(v).toLocaleString() }, // Formatters
+       { columns: ['name', 'email'] },         // Search
+       { path: '/api/users' },                 // POST
+       { path: (o) => `/api/users/${o.id}` },  // PUT
+       { path: (o) => `/api/users/${o.id}` }   // DELETE
+     );
+     // Logic for skeletons, additional formatting, etc., should be added here,
+     // and then return the extended object.
+   });
+   ```
+5. Within the Vue component itself, simply import and call your custom singleton composable: `const { list, loading, sendPost } = useUserManagement();`
+
+CHOOSING THE executeUse STRATEGY:
+1. `executeUseLocal` (PREFERRED):
+   - When to use: For most API requests and services.
+   - Key Features: Works "lazily" (lazy initialization) — initializes only when first called. The instance persists until the end of the session. This prevents overloading the application start with unnecessary requests.
+2. `executeUseGlobal`:
+   - When to use: When data or a service must be loaded/initialized IMMEDIATELY at application start (e.g., critical settings, SDKs).
+   - Key Features: Creates a single instance for the entire application. All global singletons are forcibly initialized via `executeUseGlobalInit()`.
+3. `executeUseProvide`:
+   - When to use: For state shared between a parent and a group of child components (e.g., tabs, complex forms with sub-components).
+   - Key Features: Uses provide/inject. The first component in the tree that calls the hook becomes the "provider", others become consumers.
+
+=============================================================================
+DEVELOPER GUIDE: USING `@dxtmisha/functional` AS A LIBRARY
+=============================================================================
+
+This section contains instructions and code guidelines for AI models on how to import and use the Vue-specific reactive classes, composables, and utility functions provided by this library in Vue 3 / Nuxt applications.
+
+---
+
+### 1. Reactive Storage & State Composables
+
+These composables bind browser storages reactively to Vue `Ref` objects, keeping them in sync.
+
+#### `useStorageRef` (localStorage)
+Reactively binds a key from `localStorage`.
+```typescript
+import { useStorageRef } from '@dxtmisha/functional';
+
+// Bind to key with optional initial default value
+const theme = useStorageRef<'light' | 'dark'>('theme_key', 'light');
+
+// Setting the value triggers an immediate update to localStorage reactively
+theme.value = 'dark';
+```
+
+#### `useSessionRef` (sessionStorage) & `useCookieRef` (Cookies)
+```typescript
+import { useSessionRef, useCookieRef } from '@dxtmisha/functional';
+
+// sessionStorage
+const step = useSessionRef<number>('form_step', 1);
+
+// CookieStorage
+const token = useCookieRef<string>('auth_token', '', { secure: true });
+```
+
+#### `useBroadcastValueRef` (Cross-Tab Synchronization)
+Synchronizes a state value reactively across multiple browser tabs under the same origin.
+```typescript
+import { useBroadcastValueRef } from '@dxtmisha/functional';
+
+// Synchronizes the value of the ref across tabs using BroadcastChannel
+const syncState = useBroadcastValueRef<string>('active_channel', 'idle');
+```
+
+#### `useHashRef` (URL Hash)
+Reactively binds Vue state to the URL hash parameters.
+```typescript
+import { useHashRef } from '@dxtmisha/functional';
+
+const hashPage = useHashRef<string>('page', 'home');
+```
+
+---
+
+### 2. Reactive Geolocation & Internationalization (`GeoRef`, `GeoIntlRef`, `GeoFlagRef`, `useTranslateRef`)
+
+Provides reactive integrations for internationalization APIs.
+
+#### `GeoRef` & `GeoIntlRef`
+```typescript
+import { GeoRef, useGeoIntlRef } from '@dxtmisha/functional';
+
+// Reactive tracking of user location details
+const currentCountry = GeoRef.getCountry(); // ComputedRef<string>
+
+// Reactive i18n formatter hook
+const intl = useGeoIntlRef();
+const formattedPrice = intl.currency(150, 'EUR'); // ComputedRef<string>
+```
+
+#### `useTranslateRef`
+Reactively loads and gets translation tokens.
+```typescript
+import { useTranslateRef } from '@dxtmisha/functional';
+
+const translations = useTranslateRef(['global.save', 'global.cancel']);
+// returns: ShallowRef<Record<string, string>> containing loaded translations
+```
+
+---
+
+### 3. SEO & Layout Utilities
+
+#### `useMeta`
+Manages page metadata reactively. Calling setters will update document headers and tags reactively.
+```typescript
+import { useMeta } from '@dxtmisha/functional';
+
+const metaManager = useMeta();
+metaManager.setTitle('My Product Page');
+metaManager.setDescription('Product details and configurations.');
+```
+
+#### `ScrollbarWidthRef`
+Tracks the scrollbar width reactively to solve layout shift issues.
+```typescript
+import { ScrollbarWidthRef } from '@dxtmisha/functional';
+
+const scrollbar = new ScrollbarWidthRef();
+const width = scrollbar.width; // Ref<number>
+const hasScroll = scrollbar.is; // ComputedRef<boolean>
+```
+
+---
+
+### 4. Advanced Reactivity Helpers
+
+#### `computedAsync`
+Creates a computed property that resolves its value asynchronously. Useful for async tasks inside computed getters.
+```typescript
+import { computedAsync } from '@dxtmisha/functional';
+
+// Performs asynchronous data lookup and reactively returns the result
+const asyncData = computedAsync(async () => {
+  return await fetchSomeData(activeId.value);
+}, 'initial_loading_value');
+```
+
+#### `computedEternity`
+Computes an asynchronous value once and caches it indefinitely unless manually refreshed.
+```typescript
+import { computedEternity } from '@dxtmisha/functional';
+
+const cachedData = computedEternity(async () => {
+  return await fetchStaticData();
+}, 'loading_state');
+```
+
+---
+
+### 5. List & Search Orchestration
+
+#### `ListDataRef`
+A powerful reactive state orchestrator for managing lists, groups, items, pagination, highlight paths, and selections.
+```typescript
+import { ListDataRef } from '@dxtmisha/functional';
+
+const items = ref([
+  { value: 'id1', label: 'First Option' },
+  { value: 'id2', label: 'Second Option' },
+]);
+const selectedId = ref('id1');
+
+const listData = new ListDataRef(items, selectedId);
+const isSelected = listData.isSelected; // ComputedRef<boolean>
+const nextItem = listData.getSelectedNext(); // returns next select item
+```
+
+#### `useSearchRef`
+Combines a source list, target fields, search query, and options to reactively search a list with built-in delay and highlight support.
+```typescript
+import { useSearchRef } from '@dxtmisha/functional';
+
+const query = ref('second');
+const { listSearch, loading, length } = useSearchRef(items, ['label'], query);
+```
+
+---
+
+### 6. DOM & Lazy Rendering
+
+#### `EventRef`
+Reactive wrapper for DOM events. Starts and stops event binding cleanly inside Vue component lifecycles (runs setup and teardown hooks automatically).
+```typescript
+import { EventRef } from '@dxtmisha/functional';
+
+// Listens reactively; auto-starts on setup and auto-stops on unmounted
+const keyListener = new EventRef(window, window, 'keydown', (event) => {
+  console.log('Key pressed', event.key);
+});
+```
+
+#### `useLazyRef`
+Reactive manager utilizing `IntersectionObserver` to defer rendering of off-screen components.
+```typescript
+import { useLazyRef } from '@dxtmisha/functional';
+
+const lazyManager = useLazyRef();
+const isVisible = lazyManager.addLazyItem(elementRef); // ShallowRef<boolean>
+```

package/{ai-types.txt → ai-types.md}

@@ -16,10 +16,6 @@ The following is the content of "exports" from package.json:
 
 // File: src/classes/design/DesignAbstract.d.ts
 export declare abstract class DesignAbstract<T extends Record<string, any>, C extends Record<string, any>> {
-    protected readonly props: T;
-    protected readonly callback?: ((event: C) => void) | undefined;
-    protected readonly event: C;
-    protected readonly changed: DesignChanged<T>;
     constructor(props: T, callback?: ((event: C) => void) | undefined, changed?: string[]);
     make(compelled?: boolean): this;
     makeCallback(compelled?: boolean): void;
@@ -35,8 +31,6 @@ export declare abstract class DesignAsyncAbstract<T extends Record<string, any>,
 
 // File: src/classes/design/DesignChanged.d.ts
 export declare class DesignChanged<T extends Record<string, any>> {
-    protected readonly props: T;
-    protected readonly watch: string[];
     constructor(props: T, watch?: string[]);
     is(name: string | string[]): boolean;
     isChanged(): boolean;
@@ -49,9 +43,6 @@ export declare class DesignComp<COMP extends ConstrComponent, P extends ConstrIt
 
 // File: src/classes/design/DesignComponents.d.ts
 export declare class DesignComponents<COMP extends ConstrComponent, P extends ConstrItem> {
-    protected readonly components: COMP;
-    protected readonly modification?: ConstrComponentMod<P> | undefined;
-    protected caching: Record<string, ComputedRef<any>>;
     constructor(components?: COMP, modification?: ConstrComponentMod<P> | undefined);
     is<K extends keyof COMP>(name: K): name is K;
     get<K extends keyof COMP>(name: K): COMP[K];
@@ -63,20 +54,6 @@ export declare class DesignComponents<COMP extends ConstrComponent, P extends Co
 
 // File: src/classes/design/DesignConstructorAbstract.d.ts
 export declare abstract class DesignConstructorAbstract<E extends Element, COMP extends ConstrComponent, EMITS extends ConstrItem, EXPOSE extends ConstrItem, SLOTS extends ConstrItem, CLASSES extends ConstrClasses, P extends ConstrItem> {
-    protected readonly props: Readonly<P>;
-    protected readonly options?: ConstrOptions<COMP, EMITS, P> | undefined;
-    protected readonly name: string[];
-    protected readonly element: Ref<E | undefined, E | undefined>;
-    protected readonly refs: ToRefs<P>;
-    protected readonly components: DesignComponents<COMP, P>;
-    protected readonly emits?: ConstrEmit<EMITS>;
-    protected readonly classes?: ComputedRef<CLASSES>;
-    protected classesSub?: ComputedRef<Partial<CLASSES>>;
-    protected readonly styles?: ComputedRef<ConstrStyles>;
-    protected stylesSub?: ComputedRef<ConstrStyles>;
-    protected attrs?: ConstrItem;
-    protected slots?: SLOTS;
-    protected dataExpose?: EXPOSE;
     protected constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
     protected init(): this;
     getName(): string;
@@ -91,24 +68,10 @@ export declare abstract class DesignConstructorAbstract<E extends Element, COMP
     protected abstract initClasses(): Partial<CLASSES>;
     protected abstract initStyles(): ConstrStyles;
     protected abstract initRender(): VNode | (VNode | any)[] | undefined;
-    protected initSlot<K extends keyof SLOTS>(name: K, children?: any[], props?: ConstrItem): VNode | undefined;
-    protected toClass(classes?: ConstrClass): ConstrClassObject;
-    protected toClassName<T extends ConstrItem>(classes?: ConstrItem): T;
 }
 
 // File: src/classes/ref/DatetimeRef.d.ts
 export declare class DatetimeRef {
-    protected item: Ref<NumberOrStringOrDate>;
-    protected type: Ref<GeoDate>;
-    protected code: Ref<string>;
-    protected date: Ref<Date>;
-    protected datetime: Datetime;
-    protected year: Ref<number, number>;
-    protected month: Ref<number, number>;
-    protected day: Ref<number, number>;
-    protected hour: Ref<number, number>;
-    protected minute: Ref<number, number>;
-    protected second: Ref<number, number>;
     constructor(date: RefOrNormal<NumberOrStringOrDate>, type?: RefOrNormal<GeoDate>, code?: RefOrNormal<string>);
     getItem(): Ref<NumberOrStringOrDate>;
     getDate(): Ref<Date>;
@@ -138,7 +101,6 @@ export declare class EventRef<E extends ElementOrWindow, O extends Event, D exte
 
 // File: src/classes/ref/GeoFlagRef.d.ts
 export declare class GeoFlagRef {
-    protected flag: ComputedRef<GeoFlag>;
     constructor(code?: RefOrNormal<string | undefined>);
     getCode(): string;
     get(code?: RefOrNormal<string>): ComputedRef<GeoFlagItem | undefined>;
@@ -181,25 +143,15 @@ export declare class GeoRef {
     static getLanguage(): ComputedRef<string>;
     static getStandard(): ComputedRef<string>;
     static getFirstDay(): ComputedRef<string>;
+    static getLocation(): ComputedRef<string>;
+    static getLocationCountry(): ComputedRef<string>;
+    static getLocationLanguage(): ComputedRef<string>;
     static set(code: string): void;
     static setValueDefault(code?: string | (() => string)): void;
 }
 
 // File: src/classes/ref/ListDataRef.d.ts
 export declare class ListDataRef {
-    protected readonly list: RefOrNormal<ListListInput | undefined>;
-    protected readonly focus?: RefType<ListSelectedItem | undefined> | undefined;
-    protected readonly highlight?: RefType<string | undefined> | undefined;
-    protected readonly highlightLengthStart?: RefType<number | undefined> | undefined;
-    protected readonly filterMode?: RefType<boolean | undefined> | undefined;
-    protected readonly selected?: RefType<ListSelectedList | undefined> | undefined;
-    protected readonly keyValue?: RefType<string | undefined> | undefined;
-    protected readonly keyLabel?: RefType<string | undefined> | undefined;
-    protected readonly lite?: RefType<number | undefined> | undefined;
-    protected readonly min: RefOrNormal<number | string | undefined>;
-    protected readonly max: RefOrNormal<number | string | undefined>;
-    protected readonly parent?: string | undefined;
-    protected subList: Record<any, ListDataRef>;
     constructor(list: RefOrNormal<ListListInput | undefined>, focus?: RefType<ListSelectedItem | undefined> | undefined, highlight?: RefType<string | undefined> | undefined, highlightLengthStart?: RefType<number | undefined> | undefined, filterMode?: RefType<boolean | undefined> | undefined, selected?: RefType<ListSelectedList | undefined> | undefined, keyValue?: RefType<string | undefined> | undefined, keyLabel?: RefType<string | undefined> | undefined, lite?: RefType<number | undefined> | undefined, min?: RefOrNormal<number | string | undefined>, max?: RefOrNormal<number | string | undefined>, parent?: string | undefined);
     readonly data: ComputedRef<ListList>;
     readonly liteData: ComputedRef<ListList>;
@@ -415,23 +367,71 @@ export declare const useLazyItemByMarginRef: (element: RefType<HTMLElement | und
 
 // File: src/composables/ref/useLazyRef.d.ts
 export type LazyItem = { status: ShallowRef<boolean>; ratio: ShallowRef<number>; entry: ShallowRef<IntersectionObserverEntry | undefined>; stopWatch: () => void; };
-export type LazyList = Record<string, LazyItem>;
-export declare const useLazyRef: (options?: IntersectionObserverInit) => { intersectionObserver: IntersectionObserver | undefined; getItem(element: HTMLElement): LazyItem; addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>; removeLazyItem: (element?: HTMLElement) => void; disconnectLazy: () => void | undefined; };
+export declare const useLazyRef: (options?: IntersectionObserverInit) => {
+    intersectionObserver: IntersectionObserver | undefined;
+    getItem(element: HTMLElement): LazyItem;
+    addLazyItem(element: Ref<HTMLElement | undefined>): ShallowRef<boolean, boolean>;
+    removeLazyItem: (element?: HTMLElement) => void;
+    disconnectLazy: () => void | undefined;
+};
 
 // File: src/composables/ref/useLoadingRef.d.ts
 export declare function useLoadingRef(): ShallowRef<boolean, boolean>;
 
 // File: src/composables/ref/useMeta.d.ts
-export declare const useMeta: () => Readonly<{ meta: typeof MetaStatic; title: Ref<string, string>; keyword: Ref<string, string>; description: Ref<string, string>; author: Ref<string, string>; image: Ref<string, string>; canonical: Ref<string, string>; robots: Ref<MetaRobots, MetaRobots>; siteName: Ref<string, string>; getHtmlMeta: () => string; sync: () => void; update: () => void; updateSsr: () => void; setTitle: (value: string) => void; setKeywords: (value: string) => void; setDescription: (value: string) => void; setAuthor: (value: string) => void; setImage: (value: string) => void; setCanonical: (value: string) => void; setRobots: (value: MetaRobots) => void; setSiteName: (value: string) => void; setSuffix: (suffix: string) => typeof MetaStatic; } & { init(): Readonly<any>; destroyExecute?(): void; }>;
+export declare const useMeta: () => Readonly<{
+    meta: typeof MetaStatic;
+    title: Ref<string, string>;
+    keyword: Ref<string, string>;
+    description: Ref<string, string>;
+    author: Ref<string, string>;
+    image: Ref<string, string>;
+    canonical: Ref<string, string>;
+    robots: Ref<MetaRobots, MetaRobots>;
+    siteName: Ref<string, string>;
+    getHtmlMeta: () => string;
+    sync: () => void;
+    update: () => void;
+    updateSsr: () => void;
+    setTitle: (value: string) => void;
+    setKeywords: (value: string) => void;
+    setDescription: (value: string) => void;
+    setAuthor: (value: string) => void;
+    setImage: (value: string) => void;
+    setCanonical: (value: string) => void;
+    setRobots: (value: MetaRobots) => void;
+    setSiteName: (value: string) => void;
+    setSuffix: (suffix: string) => typeof MetaStatic;
+} & {
+    init(): any;
+    destroyExecute?(): void;
+}>;
 
 // File: src/composables/ref/useRouterList.d.ts
-export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => { item: ComputedRef<T | undefined>; selected: Ref<string, string>; label: ComputedRef<NumberOrString>; list: ComputedRef<ConstrBind<T>[]>; to: (name?: string) => void; toMain(): void; };
+export declare const useRouterList: <T extends ListDataBasic>(list: RefType<ConstrBind<T>[] | undefined>, selected?: Ref<string> | string, hasTo?: boolean) => {
+    item: ComputedRef<T | undefined>;
+    selected: Ref<string, string>;
+    label: ComputedRef<NumberOrString>;
+    list: ComputedRef<ConstrBind<T>[]>;
+    to: (name?: string) => void;
+    toMain(): void;
+};
 
 // File: src/composables/ref/useSearchRef.d.ts
-export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns: K, value?: Ref<string>, options?: SearchOptions): { isSearch: ComputedRef<boolean>; search: Ref<string, string>; loading: Ref<boolean, boolean>; listSearch: ComputedRef<SearchFormatList<T, K>>; length: ComputedRef<number>; };
+export declare function useSearchRef<T extends SearchItem, K extends SearchColumns<T>>(list: SearchListInput<T>, columns: K, value?: Ref<string>, options?: SearchOptions): {
+    isSearch: ComputedRef<boolean>;
+    search: Ref<string, string>;
+    loading: Ref<boolean, boolean>;
+    listSearch: ComputedRef<SearchFormatList<T, K>>;
+    length: ComputedRef<number>;
+};
 
 // File: src/composables/ref/useSearchValueRef.d.ts
-export declare function useSearchValueRef<T extends SearchItem, K extends SearchColumns<T>>(item: SearchList<T, K>, value?: Ref<string>): { search: Ref<string, string>; searchDelay: Ref<string, string>; loading: Ref<boolean, boolean>; };
+export declare function useSearchValueRef<T extends SearchItem, K extends SearchColumns<T>>(item: SearchList<T, K>, value?: Ref<string>): {
+    search: Ref<string, string>;
+    searchDelay: Ref<string, string>;
+    loading: Ref<boolean, boolean>;
+};
 
 // File: src/composables/ref/useSessionRef.d.ts
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
@@ -459,16 +459,25 @@ export declare function computedByLanguage<T, R extends (T | undefined) = T | un
 export declare function computedEternity<T>(getter: () => Promise<T> | T, initialState?: (() => T) | T): Ref<T, T>;
 
 // File: src/functions/dxtFunctionalPlugin.d.ts
-export interface FunctionalPluginOptions { api?: ApiConfig; translate?: TranslateConfig; location?: string | (() => string); metaSuffix?: string; icons?: IconsConfig; router?: Router; errorCauses?: ErrorCenterCauseList; errorHandlers?: ErrorCenterHandlerList; }
+export interface FunctionalPluginOptions {
+    api?: ApiConfig;
+    translate?: TranslateConfig;
+    location?: string | (() => string);
+    metaSuffix?: string;
+    icons?: IconsConfig;
+    router?: Router;
+    errorCauses?: ErrorCenterCauseList;
+    errorHandlers?: ErrorCenterHandlerList;
+}
 export declare const dxtFunctionalPlugin: Plugin;
 
 // File: src/functions/executeUse.d.ts
 export declare enum ExecuteUseType { global = "global", provide = "provide", local = "local" }
 export type ExecuteUseReturn<R> = Readonly<R & { init(): Readonly<R>; destroyExecute?(): void; }>;
 export declare function executeUse<R, O extends any[], RI extends ExecuteUseReturn<R> = ExecuteUseReturn<R>>(callback: (...args: O) => R, type?: ExecuteUseType): ((...args: O) => RI) | (() => RI);
-export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<any>) | (() => Readonly<any>);
-export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<any>) | (() => Readonly<any>);
-export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<any>) | (() => Readonly<any>);
+export declare function executeUseGlobal<R>(callback: () => R): any;
+export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): any;
+export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): any;
 export declare function executeUseGlobalInit(): void;
 
 // File: src/functions/getInject.d.ts
@@ -513,12 +522,98 @@ export declare function toBind<R extends ItemList = ItemList>(extra: ItemList, v
 // File: src/functions/toBinds.d.ts
 export declare function toBinds<R extends ItemList = ItemList>(...values: (ItemList | undefined)[]): ConstrBind<R>;
 
+// File: src/library.d.ts
+export * from './classes/design/DesignAbstract';
+export * from './classes/design/DesignAsyncAbstract';
+export * from './classes/design/DesignChanged';
+export * from './classes/design/DesignComp';
+export * from './classes/design/DesignComponents';
+export * from './classes/design/DesignConstructorAbstract';
+export * from './classes/ref/DatetimeRef';
+export * from './classes/ref/EffectScopeGlobal';
+export * from './classes/ref/EventRef';
+export * from './classes/ref/GeoFlagRef';
+export * from './classes/ref/GeoIntlRef';
+export * from './classes/ref/GeoRef';
+export * from './classes/ref/ListDataRef';
+export * from './classes/ref/RouterItemRef';
+export * from './classes/ref/ScrollbarWidthRef';
+export * from './composables/ref/useApiAsyncRef';
+export * from './composables/ref/useApiDelete';
+export * from './composables/ref/useApiGet';
+export * from './composables/ref/useApiManagementAsyncRef';
+export * from './composables/ref/useApiManagementRef';
+export * from './composables/ref/useApiPost';
+export * from './composables/ref/useApiPut';
+export * from './composables/ref/useApiRef';
+export * from './composables/ref/useApiRequest';
+export * from './composables/ref/useBroadcastValueRef';
+export * from './composables/ref/useCookieRef';
+export * from './composables/ref/useFormattersRef';
+export * from './composables/ref/useGeoIntlRef';
+export * from './composables/ref/useHashRef';
+export * from './composables/ref/useLazyItemByMarginRef';
+export * from './composables/ref/useLazyRef';
+export * from './composables/ref/useLoadingRef';
+export * from './composables/ref/useMeta';
+export * from './composables/ref/useRouterList';
+export * from './composables/ref/useSearchRef';
+export * from './composables/ref/useSearchValueRef';
+export * from './composables/ref/useSessionRef';
+export * from './composables/ref/useStorageRef';
+export * from './composables/ref/useTranslateRef';
+export * from './functions/basic';
+export * from './functions/computedAsync';
+export * from './functions/computedByLanguage';
+export * from './functions/computedEternity';
+export * from './functions/dxtFunctionalPlugin';
+export * from './functions/executeUse';
+export * from './functions/getInject';
+export * from './functions/getOptions';
+export * from './functions/ref/executeFunctionRef';
+export * from './functions/ref/getApiErrorRef';
+export * from './functions/ref/getBindRef';
+export * from './functions/ref/getRef';
+export * from './functions/ref/render';
+export * from './functions/ref/setRef';
+export * from './functions/ref/toRefItem';
+export * from './functions/render/getBind';
+export * from './functions/render/getClassName';
+export * from './functions/render/getIndexForRender';
+export * from './functions/toBind';
+export * from './functions/toBinds';
+export * from './types/apiTypes';
+export * from './types/constructorTypes';
+export * from './types/listTypes';
+export * from './types/refTypes';
+export * from './types/searchTypes';
+
 // File: src/types/apiTypes.d.ts
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
-export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = { path?: RefOrNormal<string | undefined>; options?: ApiOptions; reactivity?: boolean; conditions?: RefType<boolean>; transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>; validateResponseContract?: (data: Type) => ApiDataValidation; errorContract?: ApiErrorStorageList; typeData?: ((data: Return) => boolean) | any; unmounted?: boolean; skeleton?: () => Return; };
+export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
+    path?: RefOrNormal<string | undefined>;
+    options?: ApiOptions;
+    reactivity?: boolean;
+    conditions?: RefType<boolean>;
+    transformation?: (data: Type, isResponseContractValid?: ApiDataValidation) => ApiData<Return>;
+    validateResponseContract?: (data: Type) => ApiDataValidation;
+    errorContract?: ApiErrorStorageList;
+    typeData?: ((data: Return) => boolean) | any;
+    unmounted?: boolean;
+    skeleton?: () => Return;
+};
 export type ApiManagementSearch<T extends SearchItem, K extends SearchColumns<T>> = { columns: K; value?: Ref<string>; options?: SearchOptions; };
-export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = { path?: RefOrNormal<string | undefined>; action?: (data: Return | undefined) => Promise<void> | void; transformation?: (data: T) => Return; validateRequestContract?: (data: Request) => ApiDataValidation & Return; validateResponseContract?: (data: T) => ApiDataValidation & Return; errorContract?: ApiErrorStorageList; toData?: boolean; options?: ApiOptions; };
+export type ApiManagementRequest<T, Request extends ApiFetch['request'] = ApiFetch['request'], Return extends ApiData<T> = ApiData<T>> = {
+    path?: RefOrNormal<string | undefined>;
+    action?: (data: Return | undefined) => Promise<void> | void;
+    transformation?: (data: T) => Return;
+    validateRequestContract?: (data: Request) => ApiDataValidation & Return;
+    validateResponseContract?: (data: T) => ApiDataValidation & Return;
+    errorContract?: ApiErrorStorageList;
+    toData?: boolean;
+    options?: ApiOptions;
+};
 
 // File: src/types/constructorTypes.d.ts
 export type ConstrItem = Record<string, any>;
@@ -535,8 +630,19 @@ export type ConstrClassList = Record<string, ConstrClass>;
 export type ConstrClasses = { main: ConstrClass; } & ConstrClassList;
 export type ConstrStylesItem = string | null;
 export type ConstrStyles = Record<string, ConstrStylesItem> | ConstrStyles[];
-export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = { components?: COMP; compMod?: ConstrComponentMod<P>; emits?: ConstrEmit<EMITS>; classes?: RefType<ConstrClasses>; styles?: RefType<ConstrStyles>; };
-export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = { name: string; element: Ref<E | undefined>; classes: RefType<CLASSES>; styles: RefType<ConstrStyles>; } & SETUP;
+export type ConstrOptions<COMP extends ConstrComponent, EMITS extends ConstrItem, P extends ConstrItem> = {
+    components?: COMP;
+    compMod?: ConstrComponentMod<P>;
+    emits?: ConstrEmit<EMITS>;
+    classes?: RefType<ConstrClasses>;
+    styles?: RefType<ConstrStyles>;
+};
+export type ConstrSetup<E extends Element, CLASSES extends ConstrClasses, SETUP extends ConstrItem> = {
+    name: string;
+    element: Ref<E | undefined>;
+    classes: RefType<CLASSES>;
+    styles: RefType<ConstrStyles>;
+} & SETUP;
 export type ConstrRegistration = { flag?: boolean; translate?: Record<string, string>; };
 export type ConstrBind<T> = T & Record<string, any> & { key?: string; class?: ConstrClass; style?: ConstrStyles; };
 export type ConstrPropItemOptions<T = any> = { type?: PropType<T>; required?: boolean; default?: any; validator?(value: any, props: any): boolean; };

package/dist/library.js

@@ -352,21 +352,30 @@ var Oe = class {
 	getNational(e) {
 		return I(() => this.flag.value.getNational(U(e)));
 	}
-}, J, Y = class {
+}, J = class {
 	static get() {
 		return y.get("__ui:geo-ref__", () => z(u.getItem()));
 	}
 	static getCountry() {
-		return this.country;
+		return y.get("__ui:geo-ref-country__", () => I(() => this.get().value.country));
 	}
 	static getLanguage() {
-		return this.language;
+		return y.get("__ui:geo-ref-language__", () => I(() => this.get().value.language));
 	}
 	static getStandard() {
-		return this.standard;
+		return y.get("__ui:geo-ref-standard__", () => I(() => this.get().value.standard));
 	}
 	static getFirstDay() {
-		return this.firstDay;
+		return y.get("__ui:geo-ref-first-day__", () => I(() => this.get().value.firstDay));
+	}
+	static getLocation() {
+		return y.get("__ui:geo-ref-location__", () => I(() => this.get().value.location));
+	}
+	static getLocationCountry() {
+		return y.get("__ui:geo-ref-location-country__", () => I(() => this.get().value.locationCountry));
+	}
+	static getLocationLanguage() {
+		return y.get("__ui:geo-ref-location-language__", () => I(() => this.get().value.locationLanguage));
 	}
 	static set(e) {
 		u.set(e, !0), this.get().value = u.getItem();
@@ -374,15 +383,11 @@ var Oe = class {
 	static setValueDefault(e) {
 		u.setValueDefault(e), this.get().value = u.getItem();
 	}
-};
-J = Y, H(Y, "country", I(() => J.get().value.country)), H(Y, "language", I(() => J.get().value.language)), H(Y, "standard", I(() => J.get().value.standard)), H(Y, "firstDay", I(() => J.get().value.firstDay));
-//#endregion
-//#region src/classes/ref/GeoIntlRef.ts
-var je = class {
+}, je = class {
 	constructor(e) {
 		H(this, "location", void 0), H(this, "intl", void 0), this.location = K(e), this.intl = I(() => {
 			var e;
-			return new f((e = this.location.value) == null ? Y.getLanguage().value : e);
+			return new f((e = this.location.value) == null ? J.getLanguage().value : e);
 		});
 	}
 	display(e, t) {
@@ -659,7 +664,7 @@ var je = class {
 			value: e
 		};
 	}
-}, Ne = "__ui:router-item-ref__", X = class {
+}, Ne = "__ui:router-item-ref__", Y = class {
 	static get() {
 		return y.get(Ne);
 	}
@@ -709,9 +714,9 @@ function Fe(e) {
 }
 //#endregion
 //#region src/functions/getOptions.ts
-var Ie = (e) => typeof e == "string" ? { method: e } : e || {}, Z;
-function Le(n, r, i = !0, a, o, s, c, l = !0, u = e.getItem()) {
-	let d = R(), f = K(Ie(r)), p = R(!1), m = R(!1), h = R(), g, _ = !0, v, y = () => {
+var X = (e) => typeof e == "string" ? { method: e } : e || {}, Z;
+function Ie(n, r, i = !0, a, o, s, c, l = !0, u = e.getItem()) {
+	let d = R(), f = K(X(r)), p = R(!1), m = R(!1), h = R(), g, _ = !0, v, y = () => {
 		let e = U(n);
 		return !!((!a || a.value) && e);
 	}, b = () => ({
@@ -793,19 +798,19 @@ function Le(n, r, i = !0, a, o, s, c, l = !0, u = e.getItem()) {
 		abort: () => g == null ? void 0 : g.abort()
 	};
 }
-var Re = (e) => {
+var Le = (e) => {
 	Z || (Z = e);
 };
 //#endregion
 //#region src/composables/ref/useApiAsyncRef.ts
-function ze(t, n, r = !0, i, a, o, s, c = !0, l = e.getItem()) {
-	let u = Le(t, n, r, i, a, o, s, c, l);
+function Re(t, n, r = !0, i, a, o, s, c = !0, l = e.getItem()) {
+	let u = Ie(t, n, r, i, a, o, s, c, l);
 	return u.initSsr(), u;
 }
 //#endregion
 //#region src/composables/ref/useApiRequest.ts
 function Q({ path: r, method: i = n.post, action: a, transformation: o, validateRequestContract: s, validateResponseContract: c, errorContract: l, toData: u = !0, options: d, apiInstance: f = e.getItem() }) {
-	let p = R(!1), m = K(Ie(d));
+	let p = R(!1), m = K(X(d));
 	return l && t.add(l, U(r), i), {
 		loading: p,
 		async send(e) {
@@ -840,7 +845,7 @@ function Q({ path: r, method: i = n.post, action: a, transformation: o, validate
 }
 //#endregion
 //#region src/composables/ref/useApiDelete.ts
-function Be(e) {
+function ze(e) {
 	return Q({
 		...e,
 		method: n.delete
@@ -848,7 +853,7 @@ function Be(e) {
 }
 //#endregion
 //#region src/composables/ref/useApiGet.ts
-function Ve(e) {
+function Be(e) {
 	return Q({
 		...e,
 		method: n.get
@@ -856,7 +861,7 @@ function Ve(e) {
 }
 //#endregion
 //#region src/composables/ref/useApiPost.ts
-function He(e) {
+function Ve(e) {
 	return Q({
 		...e,
 		method: n.post
@@ -864,7 +869,7 @@ function He(e) {
 }
 //#endregion
 //#region src/composables/ref/useApiPut.ts
-function Ue(e) {
+function He(e) {
 	return Q({
 		...e,
 		method: n.put
@@ -872,7 +877,7 @@ function Ue(e) {
 }
 //#endregion
 //#region src/composables/ref/useFormattersRef.ts
-function We(e, t) {
+function Ue(e, t) {
 	let n = new l(t);
 	return {
 		listFormat: I(() => n.setList(e.value).to()),
@@ -881,7 +886,7 @@ function We(e, t) {
 }
 //#endregion
 //#region src/composables/ref/useSearchValueRef.ts
-function Ge(e, t) {
+function We(e, t) {
 	let n = t == null ? R("") : t, r = R(n.value), i = R(!1), a;
 	return B(n, (t, o, s) => {
 		let c = e.getOptions().getDelay();
@@ -898,8 +903,8 @@ function Ge(e, t) {
 }
 //#endregion
 //#region src/composables/ref/useSearchRef.ts
-function Ke(e, t, n, r) {
-	let i = new v(void 0, t, void 0, r), { search: a, searchDelay: o, loading: s } = Ge(i, n), c = () => U(x(e)) || [], l = I(() => i.setValue(o.value).getItem().isSearch()), u = I(() => i.setList(c()).setValue(o.value).to());
+function Ge(e, t, n, r) {
+	let i = new v(void 0, t, void 0, r), { search: a, searchDelay: o, loading: s } = We(i, n), c = () => U(x(e)) || [], l = I(() => i.setValue(o.value).getItem().isSearch()), u = I(() => i.setList(c()).setValue(o.value).to());
 	return {
 		isSearch: l,
 		search: a,
@@ -910,9 +915,9 @@ function Ke(e, t, n, r) {
 }
 //#endregion
 //#region src/composables/ref/useApiManagementRef.ts
-function qe(e, t, n, r, i, a, o, s) {
-	let { path: c, options: l, reactivity: u, conditions: d, transformation: f, validateResponseContract: p, errorContract: m, typeData: h, unmounted: g, skeleton: _ } = e, v, y, b, x, C, w = Le(c, l, u, d, f, p, m, g, s), T = I(() => h === void 0 ? !0 : w.isStarting() ? !1 : A(h) ? h(w.data.value) : w.data.value instanceof h), E = I(() => w.isStarting() && _ ? _() : w.data.value);
-	if (t && (v = We(E, t)), n && (y = Ke(I(() => {
+function Ke(e, t, n, r, i, a, o, s) {
+	let { path: c, options: l, reactivity: u, conditions: d, transformation: f, validateResponseContract: p, errorContract: m, typeData: h, unmounted: g, skeleton: _ } = e, v, y, b, x, C, w = Ie(c, l, u, d, f, p, m, g, s), T = I(() => h === void 0 ? !0 : w.isStarting() ? !1 : A(h) ? h(w.data.value) : w.data.value instanceof h), E = I(() => w.isStarting() && _ ? _() : w.data.value);
+	if (t && (v = Ue(E, t)), n && (y = Ge(I(() => {
 		var e;
 		let t = (e = v == null ? void 0 : v.listFormat.value) == null ? w.data.value : e;
 		if (Array.isArray(t)) return t;
@@ -922,15 +927,15 @@ function qe(e, t, n, r, i, a, o, s) {
 		}, t = (t) => async (n) => {
 			A(t) && await S(t(n)), e(n);
 		};
-		r && (b = He({
+		r && (b = Ve({
 			...r,
 			action: t(r.action),
 			apiInstance: s
-		})), i && (x = Ue({
+		})), i && (x = He({
 			...i,
 			action: t(i.action),
 			apiInstance: s
-		})), a && (C = Be({
+		})), a && (C = ze({
 			...a,
 			action: t(a.action),
 			apiInstance: s
@@ -976,15 +981,15 @@ function qe(e, t, n, r, i, a, o, s) {
 }
 //#endregion
 //#region src/composables/ref/useApiManagementAsyncRef.ts
-function Je(e, t, n, r, i, a, o, s) {
-	let c = qe(e, t, n, r, i, a, o, s);
+function qe(e, t, n, r, i, a, o, s) {
+	let c = Ke(e, t, n, r, i, a, o, s);
 	return c.initSsr(), c;
 }
 //#endregion
 //#region src/composables/ref/useBroadcastValueRef.ts
-var Ye = () => y.get("__ui:broadcast-value-ref__", () => ({}));
-function Xe(e, t) {
-	let n = `broadcast--${e}`, i = Ye();
+var Je = () => y.get("__ui:broadcast-value-ref__", () => ({}));
+function Ye(e, t) {
+	let n = `broadcast--${e}`, i = Je();
 	if (n in i) return i[n];
 	let a = R(x(t));
 	if (k()) {
@@ -999,11 +1004,11 @@ function Xe(e, t) {
 }
 //#endregion
 //#region src/composables/ref/useCookieRef.ts
-var Ze = () => y.get("__ui:cookie-ref__", () => ({}));
-function Qe(e, t, n) {
-	let r = Ze();
+var Xe = () => y.get("__ui:cookie-ref__", () => ({}));
+function Ze(e, t, n) {
+	let r = Xe();
 	if (e in r) return r[e];
-	let a = new i(e), o = Xe(`__cookie:${e}`, a.get(t, n));
+	let a = new i(e), o = Ye(`__cookie:${e}`, a.get(t, n));
 	return q.run(() => {
 		B(o, (e) => {
 			a.set(e, n);
@@ -1012,14 +1017,14 @@ function Qe(e, t, n) {
 }
 //#endregion
 //#region src/composables/ref/useGeoIntlRef.ts
-function $e() {
+function Qe() {
 	return new je();
 }
 //#endregion
 //#region src/composables/ref/useHashRef.ts
-var et = () => y.get("__ui:hash-ref__", () => ({}));
-function tt(e, t) {
-	let n = et();
+var $e = () => y.get("__ui:hash-ref__", () => ({}));
+function et(e, t) {
+	let n = $e();
 	if (e in n) return n[e];
 	let r = z(p.get(e, t));
 	return k() && (q.run(() => {
@@ -1030,7 +1035,7 @@ function tt(e, t) {
 }
 //#endregion
 //#region src/composables/ref/useLazyRef.ts
-var nt = (e = { rootMargin: "128px 0px" }) => {
+var tt = (e = { rootMargin: "128px 0px" }) => {
 	let t = {}, n = k() && "IntersectionObserver" in window ? new IntersectionObserver((e) => {
 		e.forEach((e) => {
 			let n = T(e.target);
@@ -1074,16 +1079,16 @@ var nt = (e = { rootMargin: "128px 0px" }) => {
 		removeLazyItem: r,
 		disconnectLazy: () => n == null ? void 0 : n.disconnect()
 	};
-}, rt = () => y.get("__ui:lazy-item-by-margin-ref__", () => []), it = (e) => {
-	let t = rt(), n = t.find((t) => t.rootMargin === e);
+}, nt = () => y.get("__ui:lazy-item-by-margin-ref__", () => []), rt = (e) => {
+	let t = nt(), n = t.find((t) => t.rootMargin === e);
 	if (n) return n.item;
-	let r = nt({ rootMargin: e });
+	let r = tt({ rootMargin: e });
 	return t.push({
 		rootMargin: e,
 		item: r
 	}), r;
-}, at = (e, t) => {
-	let n = it(t);
+}, it = (e, t) => {
+	let n = rt(t);
 	return {
 		lazyItemStatus: n.addLazyItem(e),
 		get lazyItem() {
@@ -1093,7 +1098,7 @@ var nt = (e = { rootMargin: "128px 0px" }) => {
 };
 //#endregion
 //#region src/composables/ref/useLoadingRef.ts
-function ot() {
+function at() {
 	let e = z(h.is());
 	return k() && h.registrationEvent(({ detail: t }) => {
 		e.value = t.loading;
@@ -1101,11 +1106,11 @@ function ot() {
 }
 //#endregion
 //#region src/functions/executeUse.ts
-var st = /* @__PURE__ */ function(e) {
+var ot = /* @__PURE__ */ function(e) {
 	return e.global = "global", e.provide = "provide", e.local = "local", e;
-}({}), ct = 1, lt = ee(1e5, 999999), ut = () => `__execute_use${lt}::${ct++}`, dt = () => y.get("__ui:execute-use-global__", () => []);
+}({}), st = 1, ct = ee(1e5, 999999), lt = () => `__execute_use${ct}::${st++}`, ut = () => y.get("__ui:execute-use-global__", () => []);
 function $(e, t = "provide") {
-	let n = ut(), r, i = (t) => {
+	let n = lt(), r, i = (t) => {
 		let n = Object.freeze(e(...t));
 		return {
 			...n,
@@ -1127,23 +1132,23 @@ function $(e, t = "provide") {
 	}, s = (...e) => t === "provide" ? ce(n, void 0) || a(e) : (r || q.run(() => {
 		r = o(e);
 	}), r);
-	return t === "global" && dt().push(s), s;
+	return t === "global" && ut().push(s), s;
 }
-function ft(e) {
+function dt(e) {
 	return $(e, "global");
 }
-function pt(e) {
+function ft(e) {
 	return $(e, "provide");
 }
-function mt(e) {
+function pt(e) {
 	return $(e, "local");
 }
-function ht() {
-	dt().forEach((e) => e());
+function mt() {
+	ut().forEach((e) => e());
 }
 //#endregion
 //#region src/composables/ref/useMeta.ts
-var gt = mt(() => {
+var ht = pt(() => {
 	let e = g, t = R(e.getTitle()), n = R(e.getKeywords()), r = R(e.getDescription()), i = R(e.getImage()), a = R(e.getCanonical()), o = R(e.getRobots()), s = R(e.getAuthor()), c = R(e.getSiteName()), l = () => e.html(), u = (e) => {
 		t.value = e, x();
 	}, d = (e) => {
@@ -1200,13 +1205,13 @@ var gt = mt(() => {
 		setSiteName: v,
 		setSuffix: (t) => e.setSuffix(t)
 	};
-}), _t = () => gt(), vt = (e, t, n = !0) => {
+}), gt = () => ht(), _t = (e, t, n = !0) => {
 	var r;
 	let i = L(t) ? t : R(t || ((r = e.value) == null || (r = r[0]) == null ? void 0 : r.value) || ""), a = () => o(i.value), o = (t) => {
 		var n;
 		return (n = e.value) == null ? void 0 : n.find((e) => e.value === t);
 	}, s = (e) => {
-		e && e !== i.value && o(e) && (i.value = e, X.push({ name: e }));
+		e && e !== i.value && o(e) && (i.value = e, Y.push({ name: e }));
 	};
 	return {
 		item: I(() => a()),
@@ -1225,9 +1230,9 @@ var gt = mt(() => {
 			s((t = e.value) == null || (t = t[0]) == null ? void 0 : t.value);
 		}
 	};
-}, yt = () => y.get("__ui:session-ref__", () => ({}));
-function bt(e, t) {
-	let n = yt();
+}, vt = () => y.get("__ui:session-ref__", () => ({}));
+function yt(e, t) {
+	let n = vt();
 	if (e in n) return n[e];
 	let r = new a(e, !0), i = R(r.get(t));
 	return q.run(() => {
@@ -1236,9 +1241,9 @@ function bt(e, t) {
 }
 //#endregion
 //#region src/composables/ref/useStorageRef.ts
-var xt = () => y.get("__ui:storage-ref__", () => ({}));
-function St(e, t, n) {
-	let r = xt();
+var bt = () => y.get("__ui:storage-ref__", () => ({}));
+function xt(e, t, n) {
+	let r = bt();
 	if (e in r) return r[e];
 	let i = new a(e), o = R(i.get(t, n));
 	return q.run(() => {
@@ -1249,12 +1254,12 @@ function St(e, t, n) {
 }
 //#endregion
 //#region src/composables/ref/useTranslateRef.ts
-function Ct(e, t = b.getItem()) {
+function St(e, t = b.getItem()) {
 	let n = z(t.getListSync(e, !0)), r = async () => {
 		n.value = { ...await t.getList(e) };
 	};
 	if (k()) {
-		B(Y.getLanguage(), r);
+		B(J.getLanguage(), r);
 		for (let e in n.value) if (n.value[e] === e || n.value[e] === " ") {
 			r().then();
 			break;
@@ -1262,10 +1267,10 @@ function Ct(e, t = b.getItem()) {
 	}
 	return n;
 }
-var wt = (e) => Ct(e);
+var Ct = (e) => St(e);
 //#endregion
 //#region src/functions/computedAsync.ts
-function Tt(e, t, n, r) {
+function wt(e, t, n, r) {
 	let i = z(x(t)), a = !0, o = async () => {
 		let t = await S(e);
 		t !== n && (i.value = t);
@@ -1276,9 +1281,9 @@ function Tt(e, t, n, r) {
 }
 //#endregion
 //#region src/functions/computedByLanguage.ts
-function Et(e, t = () => void 0, n, r) {
+function Tt(e, t = () => void 0, n, r) {
 	return I(() => {
-		if (Y.get().value && (n === void 0 || n())) {
+		if (J.get().value && (n === void 0 || n())) {
 			let t = e();
 			if (t !== void 0) return t;
 		}
@@ -1287,7 +1292,7 @@ function Et(e, t = () => void 0, n, r) {
 }
 //#endregion
 //#region src/functions/computedEternity.ts
-function Dt(e, t) {
+function Et(e, t) {
 	return re((n, r) => {
 		let i = z(x(t)), a = !1, o = async () => {
 			i.value = await S(e), r();
@@ -1308,17 +1313,17 @@ function Dt(e, t) {
 }
 //#endregion
 //#region src/functions/dxtFunctionalPlugin.ts
-var Ot = { install(t, n = {}) {
-	if (n.api && e.setConfig(n.api), n.translate && b.setConfig(n.translate), n.location && Y.setValueDefault(n.location), n.icons && m.setConfig(n.icons), n.metaSuffix && _t().setSuffix(n.metaSuffix), n.router) X.set(n.router);
+var Dt = { install(t, n = {}) {
+	if (n.api && e.setConfig(n.api), n.translate && b.setConfig(n.translate), n.location && J.setValueDefault(n.location), n.icons && m.setConfig(n.icons), n.metaSuffix && gt().setSuffix(n.metaSuffix), n.router) Y.set(n.router);
 	else {
 		let e = t.config.globalProperties.$router;
-		e && X.set(e);
+		e && Y.set(e);
 	}
-	n.errorCauses && s.addList(n.errorCauses), n.errorHandlers && s.addHandlerList(n.errorHandlers), ht();
+	n.errorCauses && s.addList(n.errorCauses), n.errorHandlers && s.addHandlerList(n.errorHandlers), mt();
 } };
 //#endregion
 //#region src/functions/getInject.ts
-function kt(e) {
+function Ot(e) {
 	if (se()) {
 		let t = ce(e);
 		if (t) return t;
@@ -1326,24 +1331,24 @@ function kt(e) {
 }
 //#endregion
 //#region src/functions/ref/executeFunctionRef.ts
-function At(e) {
+function kt(e) {
 	return U(x(e));
 }
 //#endregion
 //#region src/functions/render/getBind.ts
-function jt(e, t = {}, n = "value", r = !1) {
+function At(e, t = {}, n = "value", r = !1) {
 	let i = typeof t == "string", a = i ? t : n, o = i ? {} : t;
 	return e ? e && M(e) && (a in e || r) ? W(o, e) : W(o, { [a]: e }) : i ? {} : { ...o };
 }
 //#endregion
 //#region src/functions/ref/getBindRef.ts
-function Mt(e, t = {}, n = "value") {
-	return I(() => jt(U(e), U(t), n));
+function jt(e, t = {}, n = "value") {
+	return I(() => At(U(e), U(t), n));
 }
 //#endregion
 //#region src/functions/ref/setRef.ts
-function Nt(e, t) {
+function Mt(e, t) {
 	e.value !== t && (e.value = t);
 }
 //#endregion
-export { Oe as DatetimeRef, be as DesignAbstract, xe as DesignAsyncAbstract, ye as DesignChanged, Ee as DesignComp, G as DesignComponents, De as DesignConstructorAbstract, q as EffectScopeGlobal, ke as EventRef, st as ExecuteUseType, Ae as GeoFlagRef, je as GeoIntlRef, Y as GeoRef, Me as ListDataRef, X as RouterItemRef, Pe as ScrollbarWidthRef, Tt as computedAsync, Et as computedByLanguage, Dt as computedEternity, Ot as dxtFunctionalPlugin, At as executeFunctionRef, $ as executeUse, ft as executeUseGlobal, ht as executeUseGlobalInit, mt as executeUseLocal, pt as executeUseProvide, Fe as getApiErrorRef, jt as getBind, Mt as getBindRef, Se as getClassName, Ce as getIndexForRender, kt as getInject, Ie as getOptions, U as getRef, we as render, Re as setApiRefGlobalConditions, Nt as setRef, wt as t, W as toBind, Te as toBinds, K as toRefItem, ze as useApiAsyncRef, Be as useApiDelete, Ve as useApiGet, Je as useApiManagementAsyncRef, qe as useApiManagementRef, He as useApiPost, Ue as useApiPut, Le as useApiRef, Q as useApiRequest, Xe as useBroadcastValueRef, Qe as useCookieRef, We as useFormattersRef, $e as useGeoIntlRef, tt as useHashRef, at as useLazyItemByMarginRef, nt as useLazyRef, ot as useLoadingRef, _t as useMeta, vt as useRouterList, Ke as useSearchRef, Ge as useSearchValueRef, bt as useSessionRef, St as useStorageRef, Ct as useTranslateRef };
+export { Oe as DatetimeRef, be as DesignAbstract, xe as DesignAsyncAbstract, ye as DesignChanged, Ee as DesignComp, G as DesignComponents, De as DesignConstructorAbstract, q as EffectScopeGlobal, ke as EventRef, ot as ExecuteUseType, Ae as GeoFlagRef, je as GeoIntlRef, J as GeoRef, Me as ListDataRef, Y as RouterItemRef, Pe as ScrollbarWidthRef, wt as computedAsync, Tt as computedByLanguage, Et as computedEternity, Dt as dxtFunctionalPlugin, kt as executeFunctionRef, $ as executeUse, dt as executeUseGlobal, mt as executeUseGlobalInit, pt as executeUseLocal, ft as executeUseProvide, Fe as getApiErrorRef, At as getBind, jt as getBindRef, Se as getClassName, Ce as getIndexForRender, Ot as getInject, X as getOptions, U as getRef, we as render, Le as setApiRefGlobalConditions, Mt as setRef, Ct as t, W as toBind, Te as toBinds, K as toRefItem, Re as useApiAsyncRef, ze as useApiDelete, Be as useApiGet, qe as useApiManagementAsyncRef, Ke as useApiManagementRef, Ve as useApiPost, He as useApiPut, Ie as useApiRef, Q as useApiRequest, Ye as useBroadcastValueRef, Ze as useCookieRef, Ue as useFormattersRef, Qe as useGeoIntlRef, et as useHashRef, it as useLazyItemByMarginRef, tt as useLazyRef, at as useLoadingRef, gt as useMeta, _t as useRouterList, Ge as useSearchRef, We as useSearchValueRef, yt as useSessionRef, xt as useStorageRef, St as useTranslateRef };

package/dist/src/classes/ref/GeoRef.d.ts

@@ -6,10 +6,6 @@ import { GeoItemFull } from '@dxtmisha/functional-basic';
  * Реактивный класс для работы с географическими данными.
  */
 export declare class GeoRef {
-    private static readonly country;
-    private static readonly language;
-    private static readonly standard;
-    private static readonly firstDay;
     /**
      * Information about the current country.
      *
@@ -47,6 +43,27 @@ export declare class GeoRef {
      * реактивная строка, представляющая первый день недели
      */
     static getFirstDay(): ComputedRef<string>;
+    /**
+     * Current location string.
+     *
+     * Текущее местоположение.
+     * @returns reactive string with the current location/ реактивная строка с текущим местоположением
+     */
+    static getLocation(): ComputedRef<string>;
+    /**
+     * Current country code from the location.
+     *
+     * Текущий код страны из местоположения.
+     * @returns reactive string with the current country code from location/ реактивная строка с кодом текущей страны из местоположения
+     */
+    static getLocationCountry(): ComputedRef<string>;
+    /**
+     * Current language code from the location.
+     *
+     * Текущий код языка из местоположения.
+     * @returns reactive string with the current language code from location/ реактивная строка с кодом текущего языка из местоположения
+     */
+    static getLocationLanguage(): ComputedRef<string>;
     /**
      * Changes the data by the full code.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxtmisha/functional",
   "private": false,
-  "version": "1.13.4",
+  "version": "1.13.7",
   "type": "module",
   "description": "A comprehensive library of utilities, base classes, and Vue 3 composables for reactive web development. Extends @dxtmisha/functional-basic with Composition API.",
   "keywords": [
@@ -46,10 +46,9 @@
   },
   "files": [
     "dist",
-    "ai-description.txt",
-    "ai-doc.ru.txt",
-    "ai-doc.txt",
-    "ai-types.txt",
+    "ai-description.md",
+    "ai-doc.md",
+    "ai-types.md",
     "CHANGELOG.md",
     "LICENSE",
     "package.json",

package/ai-description.txt

@@ -1,18 +0,0 @@
-This library is a collection of Vue 3-based utility classes and composables designed for building complex, reactive, and SSR-ready interfaces. It provides a standardized framework for API management, component state, geographic/localization data, and dynamic rendering.
-
-1. Core Purpose:
-An infrastructure-level toolkit for Vue 3 that abstracts asynchronous data fetching, state management, and UI rendering logic. It provides structured classes and composables to handle API lifecycle (GET/POST/PUT/DELETE), reactive data transformations, internationalization (Intl), and component orchestration.
-
-2. Usage Scenarios:
-- API Orchestration: When building complex forms, data tables, or dashboards requiring integrated state, validation (via @effect/schema compatibility), and SSR support. Use `useApiManagementRef` for unified CRUD handling or `useApiRef` for individual requests.
-- Reactive Data Management: When you need synchronized data across browser tabs (`useBroadcastValueRef`) or persistence across reloads (`useStorageRef`, `useCookieRef`).
-- Localization & Formatting: When the application needs to dynamically handle geographic data, currency formatting, file sizes, or date manipulation via `GeoIntlRef` and `useGeoIntlRef`.
-- Component Design System: When building modular UI components that require consistent prop-to-style/class mapping (`DesignConstructorAbstract`, `DesignComponents`).
-- Lifecycle & DOM Utilities: When implementing lazy loading (`useLazyRef`) or global state management using `executeUse` for singletons.
-
-3. Integration Context:
-- Vue 3 Core: Heavily leverages `Ref`, `ComputedRef`, and `provide/inject`.
-- Data Fetching: Acts as a high-level wrapper over an underlying `functional-basic` library.
-- Routing: Integrates with `vue-router` via `RouterItemRef` and `useRouterList`.
-- SSR: Provides specific `Async` variants (e.g., `useApiAsyncRef`) for server-side pre-fetching.
-- Schema Validation: Designed to work with `@effect/schema` for robust API contract validation.

package/ai-doc.ru.txt

@@ -1,45 +0,0 @@
-Это главная функциональная библиотека для среды Vue (@dxtmisha/functional). Здесь собраны утилиты, composables и реактивные классы, заточенные под Vue.
-
-ПРАВИЛА ИСПОЛЬЗОВАНИЯ:
-1. При разработке на Vue всегда отдавайте приоритет этой библиотеке для работы с логикой и composables, а не `@dxtmisha/functional-basic`.
-2. Библиотека оборачивает базовую нереактивную логику в систему реактивности Vue. Если нужная функция или класс есть здесь, они имеют абсолютный приоритет.
-3. Импортируйте утилиты из `@dxtmisha/functional` для реактивного поведения UI, composables и управления состоянием.
-
-РАБОТА С API И СОСТОЯНИЕМ (useApi / executeUse):
-Для работы с сетевыми запросами в библиотеке предусмотрен набор хуков: `useApiGet`, `useApiPost`, `useApiPut`, `useApiDelete`, `useApiRequest`, `useApiRef`, `useApiAsyncRef`, `useApiManagementRef`, `useApiManagementAsyncRef`.
-Строго соблюдайте следующие правила их применения:
-
-1. НЕ ВЫЗЫВАЙТЕ эти хуки напрямую в компонентах (SFC).
-2. Выносите всю настройку и вызовы `useApi*` в ОТДЕЛЬНЫЕ ФАЙЛЫ (сервисы / хранилища).
-3. Оборачивайте настройку API в фабрику `executeUse` (а именно: `executeUseGlobal`, `executeUseProvide` или `executeUseLocal` из `src/functions/executeUse.ts`). Это гарантирует создание синглтонов (одна точка доступа) и предотвращает создание дубликатов запросов и хранилищ состояния.
-4. Выполняйте любую дополнительную обработку запросов (например: маппинг данных, подготовка структуры для отображения скелетона перед загрузкой формы) в этом же файле, внутри коллбэка `executeUse`, а наружу возвращайте уже полностью готовый набор данных и методов.
-   *Пример правильного использования:*
-   ```ts
-   import { executeUseGlobal } from '@dxtmisha/functional';
-   import { useApiManagementRef } from '@dxtmisha/functional';
-
-   export const useUserManagement = executeUseGlobal(() => {
-     return useApiManagementRef(
-       { path: '/api/users' },                 // GET setup
-       { date: (v) => new Date(v).toLocaleString() }, // Formatters
-       { columns: ['name', 'email'] },         // Search
-       { path: '/api/users' },                 // POST
-       { path: (o) => `/api/users/${o.id}` },  // PUT
-       { path: (o) => `/api/users/${o.id}` }   // DELETE
-     );
-     // Здесь же можно добавить логику подготовки скелетонов, форматирования и т.д.
-     // и затем вернуть расширенный объект
-   });
-   ```
-5. В самом Vue-компоненте просто импортируйте и вызывайте созданный синглтон-хук: `const { list, loading, sendPost } = useUserManagement();`
-
-ВЫБОР СТРАТЕГИИ executeUse:
-1. `executeUseLocal` (ПРЕДПОЧТИТЕЛЬНО):
-   - Когда использовать: Для большинства API-запросов и сервисов.
-   - Особенности: Работает «лениво» (lazy) — инициализируется только в момент первого вызова. Экземпляр сохраняется до конца сессии. Это позволяет не перегружать старт приложения лишними запросами.
-2. `executeUseGlobal`:
-   - Когда использовать: Когда данные или сервис должны быть загружены/инициализированы СРАЗУ при старте приложения (например: критические настройки, SDK).
-   - Особенности: Создает один экземпляр на всё приложение. Все глобальные синглтоны инициализируются принудительно через `executeUseGlobalInit()`.
-3. `executeUseProvide`:
-   - Когда использовать: Для состояния, разделяемого между родителем и группой дочерних компонентов (например: табы, сложные формы с подкомпонентами).
-   - Особенности: Использует provide/inject. Первый компонент в дереве, вызвавший хук, становится «провайдером», остальные — потребителями.

package/ai-doc.txt

@@ -1,45 +0,0 @@
-This is the main functional library for the Vue environment (@dxtmisha/functional). It contains Vue-specific utilities, composables, and reactive classes.
-
-USAGE RULES:
-1. When developing in Vue, always use this library for functionality, logic, and composables instead of `@dxtmisha/functional-basic` whenever possible.
-2. It wraps basic non-reactive logic into Vue's reactivity system. If the required function or composable exists here, it has absolute priority.
-3. Import utilities from `@dxtmisha/functional` for reactive UI behavior, composables, and state management.
-
-WORKING WITH API AND STATE (useApi / executeUse):
-A set of composables is provided for network requests: `useApiGet`, `useApiPost`, `useApiPut`, `useApiDelete`, `useApiRequest`, `useApiRef`, `useApiAsyncRef`, `useApiManagementRef`, `useApiManagementAsyncRef`.
-Strictly follow these rules for their application:
-
-1. DO NOT call these composables directly in the Vue components (SFC).
-2. Move all API configurations and `useApi*` calls into SEPARATE FILES (services/stores).
-3. Wrap the API configurations inside the `executeUse` factory (specifically: `executeUseGlobal`, `executeUseProvide`, or `executeUseLocal` from `src/functions/executeUse.ts`). This guarantees the creation of managed singletons (single access point) and prevents duplicated requests and reactive states.
-4. Perform any additional request processing (e.g., data mapping, preparing structures for skeletons before loading a form) in the same file, inside the `executeUse` callback, and return a fully prepared set of data and methods.
-   *Example of correct usage:*
-   ```ts
-   import { executeUseGlobal } from '@dxtmisha/functional';
-   import { useApiManagementRef } from '@dxtmisha/functional';
-
-   export const useUserManagement = executeUseGlobal(() => {
-     return useApiManagementRef(
-       { path: '/api/users' },                 // GET setup
-       { date: (v) => new Date(v).toLocaleString() }, // Formatters
-       { columns: ['name', 'email'] },         // Search
-       { path: '/api/users' },                 // POST
-       { path: (o) => `/api/users/${o.id}` },  // PUT
-       { path: (o) => `/api/users/${o.id}` }   // DELETE
-     );
-     // Logic for skeletons, additional formatting, etc., should be added here,
-     // and then return the extended object.
-   });
-   ```
-5. Within the Vue component itself, simply import and call your custom singleton composable: `const { list, loading, sendPost } = useUserManagement();`
-
-CHOOSING THE executeUse STRATEGY:
-1. `executeUseLocal` (PREFERRED):
-   - When to use: For most API requests and services.
-   - Key Features: Works "lazily" (lazy initialization) — initializes only when first called. The instance persists until the end of the session. This prevents overloading the application start with unnecessary requests.
-2. `executeUseGlobal`:
-   - When to use: When data or a service must be loaded/initialized IMMEDIATELY at application start (e.g., critical settings, SDKs).
-   - Key Features: Creates a single instance for the entire application. All global singletons are forcibly initialized via `executeUseGlobalInit()`.
-3. `executeUseProvide`:
-   - When to use: For state shared between a parent and a group of child components (e.g., tabs, complex forms with sub-components).
-   - Key Features: Uses provide/inject. The first component in the tree that calls the hook becomes the "provider", others become consumers.