@dxtmisha/functional 1.12.1 → 1.13.2

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.13.2] - 2026-06-05
+
+### Changed / Improved
+- **Maintenance**: Version bumped to `1.13.2` to synchronize package updates across the workspace.
+
+## [1.13.1] - 2026-06-02
+
+### Changed / Improved
+- **Maintenance**: Version bumped to `1.13.1` to align with monorepo release updates.
+
+## [1.13.0] - 2026-05-29
+
+### Added
+- **refTypes**: Added `RefOrNormalOrFunction` union type representing references, normal values, or functions returning them.
+- **Functions**: Introduced `executeFunctionRef` utility function to safely execute functions or unwrap reference values in a single call.
+
+## [1.12.3] - 2026-05-25
+
+### Changed / Improved
+- **Build System**: Configured `ui-priority: 200` inside `package.json` to ensure prioritized dependency order sorting during workspace build actions.
+- **Maintenance**: Version bumped to `1.12.3` for consistency.
+
+## [1.12.2] - 2026-05-25
+
+### Changed / Improved
+- **Tests**: Configured vitest runner execution environment via the `--no-webstorage` flag inside `package.json` to avoid persistent localStorage/sessionStorage warning outputs.
+
 ## [1.12.1] - 2026-05-21
 
 ### Fixed

package/ai-description.txt

@@ -1,5 +1,10 @@
-This library is a technical SDK for Vue 3 that facilitates the construction of design systems and complex application states through reactive abstractions. Its primary function is to provide a standardized architecture for API orchestration, design component construction, and reactive utility management. It extends low-level logic from @dxtmisha/functional-basic into the Vue reactivity ecosystem.
+Core Purpose: This library is a comprehensive Vue 3 framework for reactive application architecture. It provides high-level abstractions for API orchestration (fetching, mutation, SSR, schema validation), state management (singletons, reactive storage, session/cookie handling), component design (base classes for rendering and lifecycle management), and localization/internationalization (geo-data, formatting, date management).
 
-Study this library when implementing robust API integration layers that require built-in SSR support, response contract validation, and automated mutation handling (POST/PUT/DELETE). It is indispensable for developing design systems that need base classes for tracking property changes and rendering dynamic component trees. Use its API for reactive localization (i18n), geographic data handling, SEO meta tag synchronization, and implementing singleton service patterns via provide/inject or global scopes.
+Usage Scenarios: Study this API when building complex, data-intensive Vue 3 applications requiring:
+1. Centralized, reactive API management (GET/POST/PUT/DELETE) with built-in SSR support, caching, and automatic response contract validation.
+2. Unified component architecture using base design classes for consistent styling, rendering, and lifecycle event management.
+3. Complex list handling, client-side searching, and advanced data formatting (Intl, currency, dates).
+4. Cross-tab communication or persistent reactive state storage (localStorage, sessionStorage, cookies).
+5. Global service configuration (meta tags, translation, icons, API settings) via Vue plugins.
 
-The library integrates deeply with the Vue 3 composition API and vue-router. It operates as a Vue plugin, managing global services for icons, translations, and error handling. It bridges the gap between pure functional utilities and reactive UI requirements, specifically targeting environments where SSR consistency and strict data validation are priorities.
+Integration Context: The library acts as a core infrastructure layer. It is built on top of Vue 3's Composition API and `vue-router`. It relies heavily on `@dxtmisha/functional-basic` for underlying logic. It should be treated as the primary service and utility layer that replaces manual store management (like Pinia) and repetitive API/lifecycle boilerplate by providing standardized patterns (e.g., `executeUse` for singletons) for shared state and service orchestration.