@dxtmisha/functional 1.15.7 → 1.15.8

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.15.8] - 2026-08-05
+
+### Changed
+- **ListRecord**: Refactored `ListRecord<Item extends ListDataBasic>` type definition to `Item[] | Record<string, Item>` for enhanced flexibility with custom item objects and record structures.
+- **package.json**: Expanded package `files` distribution list to include `ai-prompts` and `ai-mcp.json` context definitions.
+- **AI Documentation**: Updated JSDoc prompt rules, added MCP resource definitions (`ai-mcp.json`), and updated package metadata (`ai-description.md`, `ai-types.md`).
+
 ## [1.15.7] - 2026-08-05
 
 ### Changed

package/ai-description.md

@@ -1,7 +1,7 @@
-This library is a reactive utility and component architecture framework for Vue 3 that standardizes design system component construction, locale-aware data formatting, browser storage state, and API request lifecycle orchestration. It provides abstract component models for computing styles, classes, slots, and properties, alongside wrappers for reactive state synchronization and dynamic component rendering. Design System Architecture components abstractly encapsulate Vue component structures, automating class and style generation, property change detection, slot bindings, and dynamic component rendering. API and Network Management modules manage asynchronous HTTP request lifecycles, server-side prefetching, CRUD mutations, response contract validation, error handling, and unified client-side search or formatting pipelines. Localization and Formatting utilities deliver reactive interfaces for internationalized formatting of dates, currencies, numbers, measurement units, country flag metadata, and dynamic translation lists. Storage and State controls wrap browser local storage, session storage, cookies, broadcast channels, and URL query or hash parameters into reactive references. List and Search utilities provide reactive controllers for hierarchical list filtering, multi-item selection tracking, focus navigation, and debounced text searches. DOM and Lifecycle controls manage intersection observers for lazy loading, document head metadata, scrollbar dimensions, global loading state tracking, and reactive event listeners. Injection and Singleton utilities support managed lifecycle topologies across application, component-subtree, or closure scopes. Studying ai-types.md is mandatory when implementing custom component constructors extending base design abstract classes, defining request or response validation contracts, configuring complex API management options, typing list data inputs and selection states, setting up functional plugin options, or establishing singleton execution topologies. The library integrates directly with Vue 3 reactivity and SSR runtime paradigms, Vue Router navigation mechanisms, and core functional utility packages.
+A reactive utility and component architecture library for Vue 3 providing high-level abstract base classes, state management composables, and localized formatting helpers. It standardizes reactive API orchestration, browser storage binding, DOM visibility tracking, internationalization, and design component construction across client and server-rendered environments. Key capabilities are grouped into API and network composables for managing asynchronous HTTP requests, mutation workflows, SSR prefetching, response contract validation, error mappings, and list orchestration; design component base classes for standardized component rendering, dynamic class and style computation, prop change tracking, slot management, and element exposure; localization and formatting utilities for reactive handling of dates, numbers, currency, unit conversions, country flags, dynamic translations, and language-dependent computed properties; persistent storage composables synchronizing state with cookies, web storage, URL query or hash parameters, and cross-tab messaging; list and search helpers for managing reactive data filtering, selection state, text highlighting, debouncing, and router-bound navigation lists; and DOM system utilities for IntersectionObserver lazy visibility tracking, reactive page metadata management, global loading states, scrollbar measurements, and singleton dependency injection. Study ai-types.md when implementing abstract component constructors, defining API validation contracts or error schemas, typing complex list structures and search options, configuring singleton execution scopes, or managing reactive Vue prop and subcomponent bindings. This library integrates natively into Vue 3 and Vue Router applications through a unified global plugin that configures shared API, routing, localization, and metadata services.
 ## Mandatory Rules
-Read the corresponding file if your task relates to:
-- 'node_modules/@dxtmisha/functional/ai-prompts/api-reference.md': Scope factory initialization, reactive singletons, and REST API management patterns
-- 'node_modules/@dxtmisha/functional/ai-prompts/localization-seo.md': Geographic context, internationalization formatting, translation utilities, HTML metadata management, and scrollbar measurement
-- 'node_modules/@dxtmisha/functional/ai-prompts/reactivity-lists.md': Async reactivity helpers, list management, search filtering, and DOM event observers
-- 'node_modules/@dxtmisha/functional/ai-prompts/storage-state.md': Reactive composables for persistent browser storage, cookies, broadcast messaging, and URL hashes
+Read the corresponding file ONLY when working on a task related to (even if not working directly with this package):
+- 'node_modules/@dxtmisha/functional/ai-prompts/api-reference.md': Reactive singleton scope initialization and REST API management patterns
+- 'node_modules/@dxtmisha/functional/ai-prompts/localization-seo.md': Geographic context, locale-aware formatting, reactive translations, document metadata, and scrollbar width measurement
+- 'node_modules/@dxtmisha/functional/ai-prompts/reactivity-lists.md': Async reactivity composables, reactive list models, search filtering, and DOM observer utilities
+- 'node_modules/@dxtmisha/functional/ai-prompts/storage-state.md': Reactive composables for browser storage, cookies, cross-tab synchronization, and URL hash state

package/ai-mcp.json

@@ -1,38 +1,38 @@
 [
   {
     "uri": "@dxtmisha/functional/ai-types.md",
-    "name": "Vue Functional Reference",
+    "name": "Vue Functional Types (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "TypeScript type definitions and composable API specifications for Vue application state management, data formatting, localization, and API request handling."
+    "description": "Type definitions and interface declarations for Vue 3 composables, reactive API abstractions, i18n helpers, design constructors, and utility state managers."
   },
   {
     "uri": "@dxtmisha/functional/ai-description.md",
-    "name": "Vue Framework Architecture",
+    "name": "Vue Utility Architecture (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "Comprehensive architectural conventions and guidelines for a Vue 3 reactive utility framework, covering component construction, API lifecycle management, localization, and persistent state controls."
+    "description": "Architectural guidelines and utility reference for Vue 3 applications, covering reactive state management, API orchestration, component base classes, localization, and storage synchronization."
   },
   {
     "uri": "@dxtmisha/functional/ai-prompts/api-reference.md",
-    "name": "API Reference",
+    "name": "API Reference (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "Defines architectural patterns and usage guidelines for REST API management and scope-isolated reactive singletons within @dxtmisha/functional. Details scope factory initialization alongside reactive CRUD operations with client-side caching and contract validation."
+    "description": "Provides guidelines and usage patterns for REST API management and reactive scope-isolated singletons in @dxtmisha/functional."
   },
   {
     "uri": "@dxtmisha/functional/ai-prompts/localization-seo.md",
-    "name": "Localization and SEO",
+    "name": "Localization SEO Utilities (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "Covers locale-aware formatting, multi-key translations, geographic context management, and reactive HTML document metadata handling for SEO optimization."
+    "description": "Provides reactive utilities and helper functions for locale-aware formatting, translation primitives, geographic context, and dynamic HTML document metadata management."
   },
   {
     "uri": "@dxtmisha/functional/ai-prompts/reactivity-lists.md",
-    "name": "Reactivity and Lists",
+    "name": "Reactivity List Utilities (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "Comprehensive guide to advanced asynchronous reactivity composables, list data models, multi-field search filtering, and DOM observer utilities."
+    "description": "Comprehensive API reference for async reactivity composables, reactive list structures, debounced multi-field search helpers, and lifecycle-managed DOM observers."
   },
   {
     "uri": "@dxtmisha/functional/ai-prompts/storage-state.md",
-    "name": "Reactive Browser State",
+    "name": "Browser State Composables (@dxtmisha/functional)",
     "mimeType": "text/markdown",
-    "description": "API reference and usage examples for reactive composables managing persistent browser state and cross-tab synchronization. Covers localStorage, sessionStorage, cookies, BroadcastChannel, and URL hash state."
+    "description": "Reactive composable wrappers for persistent and synchronized browser state management, including localStorage, sessionStorage, cookies, BroadcastChannel, and URL hash fragments."
   }
 ]

package/ai-types.md

@@ -1,10 +1,18 @@
-1) All these methods are in the @dxtmisha/functional library.
+All these methods are in the @dxtmisha/functional library.
 
-import { ComputedRef, Ref, ShallowRef, ToRefs, VNode, DebuggerOptions, ComputedGetter, PropType, VNodeArrayChildren, Plugin } from 'vue';
-import { RouteLocationRaw, Router, _RouterClassic } from 'vue-router';
+import { ComputedRef, Ref, ShallowRef, ToRefs, VNode, VNodeArrayChildren, ComputedGetter, DebuggerOptions, Plugin, PropType } from 'vue';
+import { Datetime, GeoDate, GeoFirstDay, GeoHours, NumberOrStringOrDate, ElementOrString, ElementOrWindow, EventItem, EventListenerDetail, EventOptions, GeoFlag, GeoFlagItem, GeoFlagNational, ItemValue, NumberOrString, GeoItemFull, GeoUnit, ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiErrorItem, ApiFetch, FormattersListColumns, FormattersOptionsList, SearchColumns, SearchFormatList, FormattersListProp, FormattersReturn, MetaRobots, Meta, SearchItem, SearchOptions, TranslateInstance, TranslateList, ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerCallback, ErrorCenterHandlerList, IconsConfig, TranslateConfig, ItemList, ApiDefaultValue, ApiMethodItem, Undefined, NumberOrStringOrBoolean, SearchListValue } from '@dxtmisha/functional-basic';
 import { InputSocialIcons } from '@dxtmisha/media';
-import { Datetime, GeoDate, GeoFirstDay, GeoHours, NumberOrStringOrDate, ElementOrString, ElementOrWindow, EventItem, EventListenerDetail, EventOptions, GeoFlag, GeoFlagItem, GeoFlagNational, ItemValue, NumberOrString, GeoItemFull, GeoUnit, ApiInstance, ApiData, ApiDataValidation, ApiErrorStorageList, ApiFetch, ArrayToItem, FormattersListColumns, FormattersOptionsList, SearchColumns, SearchFormatList, ApiErrorItem, FormattersListProp, FormattersReturn, MetaRobots, Meta, SearchItem, SearchOptions, TranslateInstance, TranslateList, ApiConfig, ErrorCenterCauseList, ErrorCenterHandlerCallback, ErrorCenterHandlerList, IconsConfig, TranslateConfig, Undefined, NumberOrStringOrBoolean, ApiDefaultValue, SearchListValue, ItemList, ApiMethodItem } from '@dxtmisha/functional-basic';
-export * from '@dxtmisha/functional-basic';
+import { RouteLocationRaw, Router, _RouterClassic } from 'vue-router';
+export type RefType<T> = ComputedRef<T> | Ref<T>;
+export type RefUndefined<T> = RefType<T | undefined>;
+export type RefOrNormal<T> = RefType<T> | T;
+export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
+export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+export type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
 export type ApiOptions = ApiMethodItem | RefOrNormal<ApiFetch>;
 export type ApiManagementValue = ApiDefaultValue | ApiDefaultValue[];
 export type ApiManagementGet<Return extends ApiManagementValue, Type extends ApiManagementValue = Return> = {
@@ -120,15 +128,6 @@ export type ListSelectedItem = NumberOrStringOrBoolean;
 export type ListSelectedList = ListSelectedItem | ListSelectedItem[];
 export type ListName = string | number | undefined;
 export type ListNames = ListName[];
-export type RefType<T> = ComputedRef<T> | Ref<T>;
-export type RefUndefined<T> = RefType<T | undefined>;
-export type RefOrNormal<T> = RefType<T> | T;
-export type RefOrNormalOrFunction<T> = RefOrNormal<T> | (() => RefOrNormal<T>);
-export type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
-export type RawSlots = {
-    [name: string]: unknown;
-    $stable?: boolean;
-};
 export type SearchListValueRef<T extends SearchItem> = RefOrNormal<SearchListValue<T>>;
 export type SearchListInput<T extends SearchItem> = SearchListValueRef<T> | (() => SearchListValueRef<T>);
 export type SearchColumnsRef<T extends SearchItem, K extends SearchColumns<T>> = RefOrNormal<K>;
@@ -160,6 +159,7 @@ export declare class DesignComponents<COMP extends ConstrComponent, P extends Co
     renderAdd<K extends keyof COMP, PK extends keyof P>(item: any[], name: K & string, props?: P[PK] & ConstrItem | ConstrItem, children?: RawChildren | RawSlots, index?: PK & string | string): this;
 }
 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> {
+    constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, EMITS, P> | undefined);
     getName(): string;
     getDesign(): string;
     getSubClass(name: string | string[]): string;
@@ -203,13 +203,6 @@ export declare class GeoFlagRef {
     getNational(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
     getNationalLanguage(codes?: RefOrNormal<string[] | undefined>): ComputedRef<GeoFlagNational[]>;
 }
-/**
- * Reactive class for managing the formatting of numbers and dates.
- *
- * @remarks
- * Avoid using this reactive class if reactive updates are not required.
- * For non-reactive formatting, use the standard `GeoIntl` class from `@dxtmisha/functional-basic`.
- */
 export declare class GeoIntlRef {
     constructor(code?: RefOrNormal<string>);
     display(value?: RefOrNormal<string>, typeOptions?: Intl.DisplayNamesOptions['type'] | Intl.DisplayNamesOptions): ComputedRef<string>;
@@ -328,13 +321,34 @@ export declare class ScrollbarWidthRef {
 }
 /**
  * Asynchronous reactive composable for API requests with built-in SSR support.
+ * Wraps `useApiRef` and immediately calls `initSsr()` to ensure data is pre-fetched on the server side.
+ * Use this composable ONLY if you need the request to be executed on the server side during SSR.
+ * For all other cases, use `useApiRef`.
  *
  * @example
  * ```typescript
  * import { Schema as S } from '@effect/schema'
  * import { useApiAsyncRef } from '@dxtmisha/functional'
+ *
  * const userSchema = S.Struct({ id: S.Number, name: S.String })
- * const { data, loading, errorItem } = useApiAsyncRef('/users/1')
+ *
+ * const { data, loading, errorItem, isResponseContractValid } = useApiAsyncRef(
+ *   '/users/1',
+ *   { method: 'GET' },
+ *   true,
+ *   undefined,
+ *   undefined,
+ *   (data) => {
+ *     try {
+ *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
+ *     } catch (e) {
+ *       return { status: 'error', errors: e }
+ *     }
+ *   },
+ *   [
+ *     { status: 404, message: 'User not found' }
+ *   ]
+ * )
  * ```
  */
 export declare function useApiAsyncRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
@@ -350,6 +364,12 @@ export declare function useApiGet<T, Request extends ApiFetch['request'] = ApiFe
     loading: Ref<boolean, boolean>;
     send(request?: Request | undefined): Promise<Return | undefined>;
 };
+/**
+ * Asynchronous reactive composable for API management requests with built-in SSR support.
+ * Wraps `useApiManagementRef` and immediately calls `initSsr()` to ensure data is pre-fetched on the server side.
+ * Use this composable ONLY if you need the request to be executed on the server side during SSR.
+ * For all other cases, use `useApiManagementRef`.
+ */
 export declare function useApiManagementAsyncRef<Return extends ApiManagementValue, FormattersOptions extends FormattersOptionsList, Post extends Record<string, any>, Put extends Record<string, any>, Delete extends Record<string, any>, Type extends ApiManagementValue = Return, Item extends ArrayToItem<Return> = ArrayToItem<Return>, ItemFormatters extends FormattersListColumns<Item, FormattersOptions>[number] = FormattersListColumns<Item, FormattersOptions>[number], Columns extends SearchColumns<ItemFormatters> = []>(propsGet: ApiManagementGet<Return, Type>, formattersOptions?: FormattersOptions, searchOptions?: ApiManagementSearch<Item, Columns>, postRequest?: ApiManagementRequest<Post>, putRequest?: ApiManagementRequest<Put>, deleteRequest?: ApiManagementRequest<Delete>, action?: () => Promise<void> | void, apiInstance?: ApiInstance): {
     isValid: ComputedRef<boolean>;
     isResponseContractValid: ComputedRef<boolean>;
@@ -378,24 +398,35 @@ export declare function useApiManagementAsyncRef<Return extends ApiManagementVal
 };
 /**
  * A powerful composable for comprehensive API request orchestration.
+ * It centrally manages data loading (GET), list formatting, client-side searching,
+ * and mutations (POST, PUT, DELETE) through a single reactive interface.
  *
- * @note
- * This hook is recommended to be used in tandem with `executeUse` for centralized state management.
+ * @note This hook is recommended to be used in tandem with `executeUse` for centralized state management.
+ * By wrapping `useApiManagementRef` in `executeUseProvide` or `executeUseGlobal`, you can ensure
+ * a single source of truth across the component tree or the entire application.
  *
  * @remarks
  * Data formatting guidelines for `formattersOptions`:
- * - Recommended for formatting: Numbers that represent values, dates, currency, units, and statuses.
+ * - Recommended for formatting: Numbers that represent values (prices, counts), dates, currency, units, and statuses.
  * - Not recommended for formatting: Technical identifiers such as ID, UUID, account numbers, types, or internal codes.
  *
  * @example
- * ```typescript
  * const products = useApiManagementRef(
+ *   {
+ *     path: '/api/v1/products',
+ *     skeleton: () => Array(5).fill({ id: 0, name: 'Loading...', price: 0 })
+ *   },
+ *   {
+ *     price: (v) => `${v} USD`,
+ *     created_at: (v) => new Date(v).toLocaleDateString()
+ *   },
+ *   {
+ *     columns: ['name', 'category']
+ *   },
  *   { path: '/api/v1/products' },
- *   { price: (v) => `${v} USD` },
- *   { columns: ['name', 'category'] },
- *   { path: '/api/v1/products' }
+ *   { path: (data) => `/api/v1/products/${data.id}` },
+ *   { path: (data) => `/api/v1/products/${data.id}` }
  * );
- * ```
  */
 export declare function useApiManagementRef<Return extends ApiManagementValue, FormattersOptions extends FormattersOptionsList, Post extends Record<string, any>, Put extends Record<string, any>, Delete extends Record<string, any>, Type extends ApiManagementValue = Return, Item extends ArrayToItem<Return> = ArrayToItem<Return>, ItemFormatters extends FormattersListColumns<Item, FormattersOptions>[number] = FormattersListColumns<Item, FormattersOptions>[number], Columns extends SearchColumns<ItemFormatters> = []>(propsGet: ApiManagementGet<Return, Type>, formattersOptions?: FormattersOptions, searchOptions?: ApiManagementSearch<Item, Columns>, postRequest?: ApiManagementRequest<Post>, putRequest?: ApiManagementRequest<Put>, deleteRequest?: ApiManagementRequest<Delete>, action?: () => Promise<void> | void, apiInstance?: ApiInstance): {
     isValid: ComputedRef<boolean>;
@@ -457,12 +488,35 @@ export interface UseApiRef<R> {
 }
 /**
  * Main reactive composable for working with API requests in Vue.
+ * Automatically handles SSR, reactivity, caching, error storage, data validation, and transformation.
  *
  * @example
  * ```typescript
  * import { Schema as S } from '@effect/schema'
  * import { useApiRef } from '@dxtmisha/functional'
- * const { data, loading } = useApiRef('/users/1')
+ *
+ * const userSchema = S.Struct({ id: S.Number, name: S.String })
+ *
+ * const { data, loading, errorItem, isResponseContractValid } = useApiRef(
+ *   '/users/1',
+ *   { method: 'GET' },
+ *   true,
+ *   undefined,
+ *   (data) => ({ ...data, isTransformed: true }),
+ *   (data) => {
+ *     try {
+ *       return { status: 'success', data: S.decodeUnknownSync(userSchema)(data) }
+ *     } catch (e) {
+ *       return { status: 'error', errors: e }
+ *     }
+ *   },
+ *   [
+ *     {
+ *       status: 404,
+ *       message: 'User not found'
+ *     }
+ *   ]
+ * )
  * ```
  */
 export declare function useApiRef<R, T = R>(path?: RefOrNormal<string | undefined>, options?: ApiOptions, reactivity?: boolean, conditions?: RefType<boolean>, transformation?: (data: T, isResponseContractValid?: ApiDataValidation) => ApiData<R>, validateResponseContract?: (data: T) => ApiDataValidation, errorContract?: ApiErrorStorageList, unmounted?: boolean, apiInstance?: ApiInstance): UseApiRef<R>;
@@ -597,7 +651,9 @@ export declare function useSearchValueRef<T extends SearchItem, K extends Search
 export declare function useSessionRef<T>(name: string, defaultValue?: T | (() => T)): Ref<T | undefined>;
 export declare function useStorageRef<T>(name: string, defaultValue?: T | (() => T), cache?: number): Ref<T | undefined>;
 /**
- * Getting translated text by array of keys or key string.
+ * Getting the translated text by an array of keys or a string with a key.
+ * Returns a `ShallowRef` that automatically updates when the global language changes.
+ * Use `as const` for arrays to ensure proper TypeScript key inference.
  *
  * @example
  * ```typescript
@@ -608,6 +664,7 @@ export declare function useStorageRef<T>(name: string, defaultValue?: T | (() =>
 export declare function useTranslateRef<T extends (string | string[])[]>(names: T, translateInstance?: TranslateInstance): ShallowRef<TranslateList<T>>;
 export declare const t: <T extends string[]>(names: T) => ShallowRef<TranslateList<T>>;
 export declare const uiMakeFlags: () => void;
+export * from '@dxtmisha/functional-basic';
 export declare function computedAsync<R>(getter: (() => Promise<R>) | (() => R) | R, initialState?: (() => R) | R, ignore?: R, debugOptions?: DebuggerOptions): ComputedRef<R | undefined>;
 export declare function computedByLanguage<T, R extends (T | undefined) = T | undefined>(getter: ComputedGetter<R>, getterNone?: R | (() => R), conditions?: () => boolean, debugOptions?: DebuggerOptions): ComputedRef<R>;
 export declare function computedEternity<T>(getter: () => Promise<T> | T, initialState?: (() => T) | T): Ref<T, T>;
@@ -624,14 +681,21 @@ export interface FunctionalPluginOptions {
     errorCallbacks?: ErrorCenterHandlerCallback[];
 }
 /**
- * Vue plugin for initializing global functional services.
+ * Vue plugin for initializing and configuring global functional services
+ * (Api, Translate, Icons, Meta).
  *
  * @example
  * ```typescript
  * import { createApp } from 'vue'
  * import { dxtFunctionalPlugin } from '@dxtmisha/functional'
+ * import router from './router'
+ *
  * const app = createApp(App)
- * app.use(dxtFunctionalPlugin, { api: { url: 'https://api.example.com' } })
+ * app.use(dxtFunctionalPlugin, {
+ *   api: { url: 'https://api.example.com' },
+ *   metaSuffix: ' | My App',
+ *   router
+ * })
  * ```
  */
 export declare const dxtFunctionalPlugin: Plugin;
@@ -646,16 +710,28 @@ export type ExecuteUseReturn<R> = Readonly<R & {
 }>;
 /**
  * Creates a managed singleton that encapsulates initialization logic and access mode.
+ * Supports initialization strategies: 'global', 'provide', 'local'.
  *
  * @remarks
- * Use this function for API services, resource optimization, shared state, or external SDKs.
+ * Use this function for API services, shared reactive states, and singleton resource optimizations.
  *
  * @example
- * ```typescript
- * export const useUserApi = executeUseGlobal(() => useApiGet('/api/user'));
- * ```
+ * export const useUserApi = executeUseGlobal(() => {
+ *   return useApiGet('/api/user');
+ * });
+ *
+ * export const useFeatureState = executeUseProvide(() => {
+ *   const items = [];
+ *   const addItem = (item) => items.push(item);
+ *   return { items, addItem };
+ * });
  */
 export declare function executeUse<R, O extends any[], RI extends ExecuteUseReturn<R> = ExecuteUseReturn<R>>(callback: (...args: O) => R, type?: ExecuteUseType): ((...args: O) => RI) | (() => RI);
+
+/**
+ * Creates a global singleton.
+ * @remarks See {@link executeUse} for more details.
+ */
 export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -663,6 +739,11 @@ export declare function executeUseGlobal<R>(callback: () => R): (() => Readonly<
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>);
+
+/**
+ * Creates a component-scoped singleton.
+ * @remarks Best for sharing state within a component sub-tree. See {@link executeUse} for more details.
+ */
 export declare function executeUseProvide<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -670,6 +751,11 @@ export declare function executeUseProvide<R, O extends any[]>(callback: (...args
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>);
+
+/**
+ * Creates a local singleton.
+ * @remarks Best for internal state preservation within a closure. See {@link executeUse} for more details.
+ */
 export declare function executeUseLocal<R, O extends any[]>(callback: (...args: O) => R): ((...args: O) => Readonly<R & {
     init(): Readonly<R>;
     destroyExecute?(): void;
@@ -677,6 +763,7 @@ export declare function executeUseLocal<R, O extends any[]>(callback: (...args:
     init(): Readonly<R>;
     destroyExecute?(): void;
 }>);
+
 export declare function executeUseGlobalInit(): void;
 export declare function getInject<T>(name: string): T | undefined;
 export declare const getOptions: (options?: ApiOptions) => RefOrNormal<ApiFetch>;

package/dist/library.js

@@ -3,7 +3,7 @@ import { computed as F, customRef as oe, effectScope as se, getCurrentInstance a
 import { MediaSocial as be } from "@dxtmisha/media";
 export * from "@dxtmisha/functional-basic";
 //#endregion
-//#region \0@oxc-project+runtime@0.138.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/typeof.js
 function B(e) {
 	"@babel/helpers - typeof";
 	return B = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
@@ -13,7 +13,7 @@ function B(e) {
 	}, B(e);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.138.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPrimitive.js
 function xe(e, t) {
 	if (B(e) != "object" || !e) return e;
 	var n = e[Symbol.toPrimitive];
@@ -25,13 +25,13 @@ function xe(e, t) {
 	return (t === "string" ? String : Number)(e);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.138.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPropertyKey.js
 function Se(e) {
 	var t = xe(e, "string");
 	return B(t) == "symbol" ? t : t + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.138.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/defineProperty.js
 function V(e, t, n) {
 	return (t = Se(t)) in e ? Object.defineProperty(e, t, {
 		value: n,
@@ -582,10 +582,10 @@ var Me = class {
 			return !!e && this.mapItems.value.findIndex((t) => M(t.index, e)) !== -1;
 		})), V(this, "isSelectedMin", F(() => {
 			let e = Number(H(this.min) || 0);
-			return e > 0 ? this.selectedListInGroup.value.length >= e : !1;
+			return e > 0 && this.selectedListInGroup.value.length >= e;
 		})), V(this, "isSelectedMax", F(() => {
 			let e = Number(H(this.max) || 9999999);
-			return e > 0 ? this.selectedListInGroup.value.length >= e : !1;
+			return e > 0 && this.selectedListInGroup.value.length >= e;
 		})), V(this, "selectedList", F(() => {
 			let e = this.getSelected();
 			return e && this.isSelected.value ? this.mapItems.value.filter((t) => M(t.index, e)) : [];

package/dist/types/listTypes.d.ts

@@ -28,7 +28,7 @@ export type ListList<Item extends ListDataBasic = ListDataBasic> = ListDataItem<
  * List or record structure for list data/
  * Структура списка или записи для данных списка
  */
-export type ListRecord<Item extends ListDataBasic = ListDataBasic> = ListList<Item> | Record<string, any>;
+export type ListRecord<Item extends ListDataBasic = ListDataBasic> = Item[] | Record<string, Item>;
 /**
  * Extended list item with additional state properties/
  * Расширенный элемент списка с дополнительными свойствами состояния

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxtmisha/functional",
   "private": false,
-  "version": "1.15.7",
+  "version": "1.15.8",
   "type": "module",
   "description": "A comprehensive library of utilities, base classes, and Vue 3 composables for reactive web development — API orchestration, state singletons (executeUse), storage sync, i18n, formatters, and component design. Extends @dxtmisha/functional-basic.",
   "keywords": [