@gnwebsoft/ui 3.0.8 → 3.0.9

package/dist/utils/index.d.cts

@@ -1,4 +1,4 @@
-import { PostModel, ApiResponse, ListResponse, ValidationErrors } from '../types/index.cjs';
+import { PostModel, ApiResponse, ListResponse, JsonObject, RequestOptions, ValidationErrors } from '../types/index.cjs';
 import { PickerValidDate } from '@mui/x-date-pickers';
 import { useLocalizationContext } from '@mui/x-date-pickers/internals';
 import * as react_hook_form from 'react-hook-form';
@@ -6,26 +6,28 @@ import { FieldValues, UseFormSetError, Control, DeepPartialSkipArrayKey, Path, P
 import { z } from 'zod';
 import '@mui/x-data-grid';
 import '../AsyncSelectPayload-B9-6l33R.cjs';
+import '../events-BcHVCLBz.cjs';
+import 'react';
 
 declare class api {
     static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
-    static post<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static post<T>(url: string, body?: JsonObject): Promise<ApiResponse<T>>;
     static get<T>(url: string): Promise<ApiResponse<T>>;
     static delete<T>(url: string): Promise<ApiResponse<T>>;
-    static put<T>(url: string, body?: any): Promise<ApiResponse<T>>;
-    static fetch(url: string, options?: any): Promise<Response>;
-    static tempFetch<T>(url: string, options?: any): Promise<ApiResponse<T>>;
+    static put<T>(url: string, body?: JsonObject): Promise<ApiResponse<T>>;
+    static fetch(url: string, options?: RequestInit): Promise<Response>;
+    static tempFetch<T>(url: string, options?: RequestOptions): Promise<ApiResponse<T>>;
     static upload<T>(url: string, formData: FormData): Promise<ApiResponse<T>>;
 }
 
 declare class api2 {
     static filter<T, TFilter>(url: string, postModel: PostModel<TFilter>): Promise<ApiResponse<ListResponse<T>>>;
-    static post<T>(url: string, body?: any): Promise<ApiResponse<T>>;
+    static post<T>(url: string, body?: JsonObject): Promise<ApiResponse<T>>;
     static get<T>(url: string): Promise<ApiResponse<T>>;
     static delete<T>(url: string): Promise<ApiResponse<T>>;
-    static put<T>(url: string, body?: any): Promise<ApiResponse<T>>;
-    static fetch(url: string, options?: any): Promise<Response>;
-    static tempFetch<T>(url: string, options?: any): Promise<ApiResponse<T>>;
+    static put<T>(url: string, body?: JsonObject): Promise<ApiResponse<T>>;
+    static fetch(url: string, options?: RequestInit): Promise<Response>;
+    static tempFetch<T>(url: string, options?: RequestOptions): Promise<ApiResponse<T>>;
     static upload<T>(url: string, formData: FormData): Promise<ApiResponse<T>>;
 }
 
@@ -90,9 +92,7 @@ declare class api2 {
  *
  * @public
  */
-declare const flattenObjectKeys: (obj: any, prefix?: string) => {
-    [x: string]: any;
-};
+declare const flattenObjectKeys: (obj: unknown, prefix?: string) => Record<string, unknown>;
 
 declare function getTimezone<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: TDate): string | null;
 
@@ -364,4 +364,320 @@ declare const typedWatch: {
     readonly selector: <TFieldValues extends react_hook_form.FieldValues, TName extends react_hook_form.Path<TFieldValues>, TOutput>(control: react_hook_form.Control<TFieldValues>, name: TName, selector: (value: react_hook_form.PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
 };
 
-export { type PathArray, api, api2, flattenObjectKeys, getTimezone, handleServerErrors, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools, typedWatch, useWatchBatch, useWatchBoolean, useWatchConditional, useWatchDebounced, useWatchDefault, useWatchField, useWatchFields, useWatchForm, useWatchSelector, useWatchTransform };
+/**
+ * Type guard utilities for runtime type checking
+ *
+ * @packageDocumentation
+ */
+/**
+ * Type guard to check if a value is a non-null object (excluding arrays)
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object
+ *
+ * @example
+ * ```typescript
+ * if (isRecord(value)) {
+ *   // value is Record<string, unknown>
+ *   const keys = Object.keys(value);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard to check if an object has a specific property
+ *
+ * @param obj - The object to check
+ * @param key - The property key to look for
+ * @returns True if the object has the property
+ *
+ * @example
+ * ```typescript
+ * if (hasProperty(obj, 'name')) {
+ *   // obj is Record<'name', unknown>
+ *   console.log(obj.name);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function hasProperty<K extends PropertyKey>(obj: unknown, key: K): obj is Record<K, unknown>;
+/**
+ * Type guard to check if a value is a non-empty string
+ *
+ * @param value - The value to check
+ * @returns True if the value is a non-empty string
+ *
+ * @example
+ * ```typescript
+ * if (isNonEmptyString(value)) {
+ *   // value is string with length > 0
+ *   console.log(value.toUpperCase());
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a valid array
+ *
+ * @param value - The value to check
+ * @returns True if the value is an array
+ *
+ * @example
+ * ```typescript
+ * if (isArray(value)) {
+ *   // value is unknown[]
+ *   value.forEach(item => console.log(item));
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Type guard to check if a value is a non-empty array
+ *
+ * @param value - The value to check
+ * @returns True if the value is a non-empty array
+ *
+ * @example
+ * ```typescript
+ * if (isNonEmptyArray(items)) {
+ *   // items is [T, ...T[]] - guaranteed to have at least one element
+ *   const first = items[0];  // Safe access
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]];
+/**
+ * Type guard to check if a value is a function
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function
+ *
+ * @example
+ * ```typescript
+ * if (isFunction(callback)) {
+ *   // callback is (...args: unknown[]) => unknown
+ *   callback();
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isFunction(value: unknown): value is (...args: readonly unknown[]) => unknown;
+/**
+ * Type guard to check if a value is a string
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string (including empty string)
+ *
+ * @example
+ * ```typescript
+ * if (isString(value)) {
+ *   // value is string
+ *   console.log(value.length);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a number (excluding NaN)
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid number
+ *
+ * @example
+ * ```typescript
+ * if (isNumber(value)) {
+ *   // value is number (not NaN)
+ *   const doubled = value * 2;
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard to check if a value is a boolean
+ *
+ * @param value - The value to check
+ * @returns True if the value is a boolean
+ *
+ * @example
+ * ```typescript
+ * if (isBoolean(value)) {
+ *   // value is boolean
+ *   console.log(!value);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Type guard to check if a value is null
+ *
+ * @param value - The value to check
+ * @returns True if the value is null
+ *
+ * @example
+ * ```typescript
+ * if (isNull(value)) {
+ *   // value is null
+ *   return defaultValue;
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isNull(value: unknown): value is null;
+/**
+ * Type guard to check if a value is undefined
+ *
+ * @param value - The value to check
+ * @returns True if the value is undefined
+ *
+ * @example
+ * ```typescript
+ * if (isUndefined(value)) {
+ *   // value is undefined
+ *   return defaultValue;
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Type guard to check if a value is null or undefined
+ *
+ * @param value - The value to check
+ * @returns True if the value is nullish
+ *
+ * @example
+ * ```typescript
+ * if (isNullish(value)) {
+ *   // value is null | undefined
+ *   return defaultValue;
+ * }
+ *
+ * if (!isNullish(value)) {
+ *   // value is NonNullable<typeof value>
+ *   console.log(value);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isNullish(value: unknown): value is null | undefined;
+/**
+ * Type guard to check if a value is defined (not null or undefined)
+ *
+ * @param value - The value to check
+ * @returns True if the value is not null or undefined
+ *
+ * @example
+ * ```typescript
+ * const filtered = items.filter(isDefined);
+ * // filtered has type: NonNullable<T>[]
+ * ```
+ *
+ * @public
+ */
+declare function isDefined<T>(value: T): value is NonNullable<T>;
+/**
+ * Type guard to check if a value is a Date object
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Date
+ *
+ * @example
+ * ```typescript
+ * if (isDate(value)) {
+ *   // value is Date
+ *   console.log(value.toISOString());
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isDate(value: unknown): value is Date;
+/**
+ * Type guard to check if a value is a Promise
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Promise
+ *
+ * @example
+ * ```typescript
+ * if (isPromise(value)) {
+ *   // value is Promise<unknown>
+ *   const result = await value;
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isPromise(value: unknown): value is Promise<unknown>;
+/**
+ * Type guard to check if an error is an Error instance
+ *
+ * @param error - The error to check
+ * @returns True if the error is an Error instance
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   // ...
+ * } catch (error) {
+ *   if (isError(error)) {
+ *     // error is Error
+ *     console.error(error.message);
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function isError(error: unknown): error is Error;
+/**
+ * Type guard to check if a value matches a specific type using a validator function
+ *
+ * @param value - The value to check
+ * @param validator - Function that returns true if value matches the type
+ * @returns True if the value matches the type
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   id: string;
+ *   name: string;
+ * }
+ *
+ * const isUser = (value: unknown): value is User =>
+ *   isRecord(value) &&
+ *   hasProperty(value, 'id') &&
+ *   hasProperty(value, 'name') &&
+ *   isString(value.id) &&
+ *   isString(value.name);
+ *
+ * if (isUser(data)) {
+ *   // data is User
+ *   console.log(data.name);
+ * }
+ * ```
+ *
+ * @public
+ */
+declare function matches<T>(value: unknown, validator: (value: unknown) => value is T): value is T;
+
+export { type PathArray, api, api2, flattenObjectKeys, getTimezone, handleServerErrors, hasProperty, isArray, isBoolean, isDate, isDefined, isError, isFunction, isNonEmptyArray, isNonEmptyString, isNull, isNullish, isNumber, isPromise, isRecord, isString, isUndefined, matches, propertyExists, readValueAsDate, removeLeadingTrailingSlashes, schemaTools, typedWatch, useWatchBatch, useWatchBoolean, useWatchConditional, useWatchDebounced, useWatchDefault, useWatchField, useWatchFields, useWatchForm, useWatchSelector, useWatchTransform };