@gnwebsoft/ui 4.0.2 → 4.0.4

package/dist/utils/index.d.ts

@@ -0,0 +1,11 @@
+export { default as api } from "./api";
+export { default as api2 } from "./api2";
+export * from "./flattenObjectKeys";
+export * from "./getTimezone";
+export * from "./handleServerErrors";
+export * from "./propertyExists";
+export * from "./readValueAsDate";
+export * from "./removeLeadingTrailingSlashes";
+export * from "./schemaTools";
+export * from "./typeGuards";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEzC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,eAAe,CAAC;AAE9B,cAAc,sBAAsB,CAAC;AAErC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,mBAAmB,CAAC;AAElC,cAAc,gCAAgC,CAAC;AAE/C,cAAc,eAAe,CAAC;AAM9B,cAAc,cAAc,CAAC"}

package/dist/utils/index.js

@@ -24,7 +24,7 @@ import {
   propertyExists,
   removeLeadingTrailingSlashes,
   schemaTools
-} from "../chunk-PUQIPRL2.js";
+} from "../chunk-XN3KVY4J.js";
 import {
   readValueAsDate
 } from "../chunk-FYU2OIMD.js";

package/dist/utils/propertyExists.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type-safe property existence checker that acts as a type guard.
+ *
+ * Checks if a given property exists on an object and narrows the TypeScript type
+ * to include that property. This is useful for safely accessing properties on
+ * objects of unknown structure while maintaining type safety.
+ *
+ * @template X - The type of the object being checked
+ * @template Y - The type of the property key (extends PropertyKey)
+ *
+ * @param obj - The object to check for the property
+ * @param prop - The property key to check for existence
+ *
+ * @returns A type predicate indicating whether the property exists on the object.
+ *          If true, the object type is narrowed to include the specified property.
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { name: "John", age: 30 };
+ *
+ * if (propertyExists(data, "name")) {
+ *   // TypeScript now knows data has a 'name' property
+ *   console.log(data.name); // Type-safe access
+ * }
+ *
+ * // Check for nested property existence
+ * if (propertyExists(obj, "user") && propertyExists(obj.user, "id")) {
+ *   console.log(obj.user.id); // Safe nested access
+ * }
+ * ```
+ *
+ * @since 2.18.45
+ */
+export declare function propertyExists<X, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+//# sourceMappingURL=propertyExists.d.ts.map

package/dist/utils/propertyExists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyExists.d.ts","sourceRoot":"","sources":["../../src/utils/propertyExists.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACrD,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,GACN,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAM/B"}

package/dist/utils/readValueAsDate.d.ts

@@ -0,0 +1,4 @@
+import type { PickerValidDate } from "@mui/x-date-pickers";
+import type { useLocalizationContext } from "@mui/x-date-pickers/internals";
+export declare function readValueAsDate<TDate extends PickerValidDate>(adapter: ReturnType<typeof useLocalizationContext>, value: string | null | TDate): TDate | null;
+//# sourceMappingURL=readValueAsDate.d.ts.map

package/dist/utils/readValueAsDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readValueAsDate.d.ts","sourceRoot":"","sources":["../../src/utils/readValueAsDate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,wBAAgB,eAAe,CAAC,KAAK,SAAS,eAAe,EAC3D,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,EAClD,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAC3B,KAAK,GAAG,IAAI,CAUd"}

package/dist/utils/removeLeadingTrailingSlashes.d.ts

@@ -0,0 +1,2 @@
+export declare const removeLeadingTrailingSlashes: (route: string) => string;
+//# sourceMappingURL=removeLeadingTrailingSlashes.d.ts.map

package/dist/utils/removeLeadingTrailingSlashes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeLeadingTrailingSlashes.d.ts","sourceRoot":"","sources":["../../src/utils/removeLeadingTrailingSlashes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,GAAI,OAAO,MAAM,WAEzD,CAAC"}

package/dist/utils/schemaTools.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const schemaTools: {
+    date: ({ message }?: {
+        message?: string;
+    }) => z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>;
+    nullableDate: ({ message }?: {
+        message?: string;
+    }) => z.ZodPipe<z.ZodPipe<z.ZodCoercedString<unknown>, z.ZodTransform<string | null, string>>, z.ZodTransform<string | null, string | null>>;
+    dateRange: ({ message }?: {
+        message?: string;
+    }) => z.ZodObject<{
+        start: z.ZodCoercedDate<unknown>;
+        end: z.ZodCoercedDate<unknown>;
+    }, z.core.$strip>;
+    requiredString: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodString;
+    email: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    url: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    phone: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    alphanumeric: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    slug: ({ message }?: {
+        message?: string;
+    }) => z.ZodString;
+    positiveNumber: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    nonNegativeNumber: ({ message, max }?: {
+        message?: string;
+        max?: number;
+    }) => z.ZodNumber;
+    integer: ({ message, min, max }?: {
+        message?: string;
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    percentage: ({ message }?: {
+        message?: string;
+    }) => z.ZodNumber;
+    nonEmptyArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    uniqueArray: <T>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>;
+    requiredBoolean: ({ message }?: {
+        message?: string;
+    }) => z.ZodBoolean;
+    nonEmptyObject: <T extends Record<string, unknown>>(schema: z.ZodSchema<T>, { message }?: {
+        message?: string;
+    }) => z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>;
+    fileSize: ({ maxSize, message }: {
+        maxSize: number;
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    fileType: ({ allowedTypes, message }: {
+        allowedTypes: string[];
+        message?: string;
+    }) => z.ZodCustom<File, File>;
+    conditional: <T, U>(condition: (data: T) => boolean, trueSchema: z.ZodSchema<U>, falseSchema: z.ZodSchema<U>) => z.ZodUnion<readonly [z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>, z.ZodType<U, unknown, z.core.$ZodTypeInternals<U, unknown>>]>;
+    transform: {
+        toLowerCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toUpperCase: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        trim: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        toNumber: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+        toBoolean: z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>;
+        parseJson: <T>(schema: z.ZodSchema<T>) => z.ZodPipe<z.ZodString, z.ZodTransform<Awaited<T>, string>>;
+    };
+};
+//# sourceMappingURL=schemaTools.d.ts.map

package/dist/utils/schemaTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaTools.d.ts","sourceRoot":"","sources":["../../src/utils/schemaTools.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;yBAEF;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;iCASZ;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;8BASvB;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;;;;6CASL;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;0BAMnE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;wBAKtB;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;0BAIlB;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;iCAIb;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;yBAI5B;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;6CAKA;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;2CAMlD;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;sCAKvC;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;+BAMvD;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;oBAM9B,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAe;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;kBAI9D,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAe;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;oCAO3C;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;qBAMlC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAe;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;qCAM5E;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;0CAMhC;QAAE,YAAY,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;kBAOpE,CAAC,EAAE,CAAC,aACL,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,cACnB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,eACb,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;;;;;;;oBAsBf,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;;CAwBxC,CAAC"}

package/dist/utils/typeGuards.d.ts

@@ -0,0 +1,316 @@
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function matches<T>(value: unknown, validator: (value: unknown) => value is T): value is T;
+//# sourceMappingURL=typeGuards.d.ts.map

package/dist/utils/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["../../src/utils/typeGuards.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAC/C,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,CAAC,GACL,GAAG,IAAI,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAE3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,EAAE,CAEjE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAEvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,KAAK,OAAO,CAEnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,GAAG,SAAS,CAEnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAE9D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAMnE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,GACxC,KAAK,IAAI,CAAC,CAEZ"}

package/dist/utils/watch/core.d.ts

@@ -0,0 +1,22 @@
+import type { Path, Control, PathValue, FieldValues, DeepPartialSkipArrayKey } from "react-hook-form";
+/**
+ * Core watch functions for React Hook Form
+ * These are the primary building blocks for form watching
+ */
+/**
+ * Utility type to ensure array elements are all Path<T>
+ */
+export type PathArray<T extends FieldValues> = ReadonlyArray<Path<T>>;
+/**
+ * Hook to watch entire form - returns all form values
+ */
+export declare const useWatchForm: <TFieldValues extends FieldValues>(control: Control<TFieldValues>) => DeepPartialSkipArrayKey<TFieldValues>;
+/**
+ * Hook to watch single field by path - supports any nested path
+ */
+export declare const useWatchField: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName) => PathValue<TFieldValues, TName>;
+/**
+ * Hook to watch multiple fields by paths - returns array of values
+ */
+export declare const useWatchFields: <TFieldValues extends FieldValues, TNames extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, names: TNames) => Array<PathValue<TFieldValues, TNames[number]>>;
+//# sourceMappingURL=core.d.ts.map

package/dist/utils/watch/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/utils/watch/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,OAAO,EACP,SAAS,EACT,WAAW,EACX,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAGzB;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,WAAW,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,YAAY,SAAS,WAAW,EAC3D,SAAS,OAAO,CAAC,YAAY,CAAC,KAC7B,uBAAuB,CAAC,YAAY,CAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAEhC,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,KACV,SAAS,CAAC,YAAY,EAAE,KAAK,CAAgC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,YAAY,SAAS,WAAW,EAChC,MAAM,SAAS,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAEhD,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,OAAO,MAAM,KACZ,KAAK,CAAC,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAyF,CAAC"}

package/dist/utils/watch/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Enhanced TypeScript utilities for React Hook Form's useWatch
+ *
+ * This module provides a comprehensive set of type-safe watch functions
+ * with better ergonomics and additional functionality.
+ *
+ * @example
+ * ```typescript
+ * import { useWatchField, useWatchBoolean, typedWatch } from 'src/utils/watch';
+ *
+ * // Direct usage (inside React components)
+ * const email = useWatchField(control, 'user.email');
+ * const isAdmin = useWatchBoolean(control, 'user.isAdmin');
+ *
+ * // Object-based usage (inside React components)
+ * const email = typedWatch.field(control, 'user.email');
+ * const isAdmin = typedWatch.boolean(control, 'user.isAdmin');
+ * ```
+ */
+export { useWatchForm, useWatchField, useWatchFields } from './core';
+export { useWatchBatch, useWatchDefault, useWatchBoolean, useWatchSelector, useWatchTransform, useWatchDebounced, useWatchConditional, } from './utilities';
+export type { PathArray } from './core';
+/**
+ * Organized utilities by use case
+ * Provides a convenient object-based API for all watch functions
+ */
+export declare const typedWatch: {
+    /** Watch entire form */
+    readonly form: <TFieldValues extends import("react-hook-form").FieldValues>(control: import("react-hook-form").Control<TFieldValues>) => import("react-hook-form").DeepPartialSkipArrayKey<TFieldValues>;
+    /** Watch single field */
+    readonly field: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>>(control: import("react-hook-form").Control<TFieldValues>, name: TName) => import("react-hook-form").PathValue<TFieldValues, TName>;
+    /** Watch multiple fields */
+    readonly fields: <TFieldValues extends import("react-hook-form").FieldValues, TNames extends ReadonlyArray<import("react-hook-form").Path<TFieldValues>>>(control: import("react-hook-form").Control<TFieldValues>, names: TNames) => Array<import("react-hook-form").PathValue<TFieldValues, TNames[number]>>;
+    /** Watch with transformation */
+    readonly transform: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>, TOutput>(control: import("react-hook-form").Control<TFieldValues>, name: TName, transform: (value: import("react-hook-form").PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+    /** Watch with default value */
+    readonly withDefault: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>>(control: import("react-hook-form").Control<TFieldValues>, name: TName, defaultValue: import("react-hook-form").PathValue<TFieldValues, TName>) => import("react-hook-form").PathValue<TFieldValues, TName>;
+    /** Watch as boolean */
+    readonly boolean: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>>(control: import("react-hook-form").Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+    /** Watch multiple with custom keys */
+    readonly batch: <TFieldValues extends import("react-hook-form").FieldValues, TFields extends ReadonlyArray<import("react-hook-form").Path<TFieldValues>>>(control: import("react-hook-form").Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: import("react-hook-form").PathValue<TFieldValues, K>; };
+    /** Watch conditionally */
+    readonly conditional: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>>(control: import("react-hook-form").Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: import("react-hook-form").PathValue<TFieldValues, TName>) => import("react-hook-form").PathValue<TFieldValues, TName> | undefined;
+    /** Watch with debouncing */
+    readonly debounced: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>>(control: import("react-hook-form").Control<TFieldValues>, name: TName, delay?: number) => import("react-hook-form").PathValue<TFieldValues, TName>;
+    /** Watch with selector */
+    readonly selector: <TFieldValues extends import("react-hook-form").FieldValues, TName extends import("react-hook-form").Path<TFieldValues>, TOutput>(control: import("react-hook-form").Control<TFieldValues>, name: TName, selector: (value: import("react-hook-form").PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/watch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/watch/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAGrE,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAcxC;;;GAGG;AACH,eAAO,MAAM,UAAU;IAErB,wBAAwB;;IAExB,yBAAyB;;IAEzB,4BAA4B;;IAI5B,gCAAgC;;IAEhC,+BAA+B;;IAE/B,uBAAuB;;IAEvB,sCAAsC;;IAEtC,0BAA0B;;IAE1B,4BAA4B;;IAE5B,0BAA0B;;CAElB,CAAC"}

package/dist/utils/watch/utilities.d.ts

@@ -0,0 +1,34 @@
+import type { Path, Control, PathValue, FieldValues } from "react-hook-form";
+/**
+ * Utility watch functions for React Hook Form
+ * Enhanced functionality for specific use cases
+ */
+/**
+ * Watch field with transformation/selector
+ */
+export declare const useWatchTransform: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, transform: (value: PathValue<TFieldValues, TName>) => TOutput) => TOutput;
+/**
+ * Watch field with default fallback value
+ */
+export declare const useWatchDefault: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field as boolean with guaranteed boolean return
+ */
+export declare const useWatchBoolean: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, defaultValue?: boolean) => boolean;
+/**
+ * Watch multiple fields and return an object with field paths as keys
+ */
+export declare const useWatchBatch: <TFieldValues extends FieldValues, TFields extends ReadonlyArray<Path<TFieldValues>>>(control: Control<TFieldValues>, fields: TFields) => { [K in TFields[number]]: PathValue<TFieldValues, K>; };
+/**
+ * Watch field conditionally based on boolean flag
+ */
+export declare const useWatchConditional: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, shouldWatch: boolean, fallback?: PathValue<TFieldValues, TName>) => PathValue<TFieldValues, TName> | undefined;
+/**
+ * Watch field with debounced updates
+ */
+export declare const useWatchDebounced: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>>(control: Control<TFieldValues>, name: TName, delay?: number) => PathValue<TFieldValues, TName>;
+/**
+ * Watch field with memoized selector function
+ */
+export declare const useWatchSelector: <TFieldValues extends FieldValues, TName extends Path<TFieldValues>, TOutput>(control: Control<TFieldValues>, name: TName, selector: (value: PathValue<TFieldValues, TName>) => TOutput, deps?: React.DependencyList) => TOutput;
+//# sourceMappingURL=utilities.d.ts.map

package/dist/utils/watch/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/utils/watch/utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EACJ,OAAO,EACP,SAAS,EACT,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAGzB;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAChC,OAAO,EAEP,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,OAAO,KAC5D,OAIF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAEhC,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,cAAc,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,KAC3C,SAAS,CAAC,YAAY,EAAE,KAAK,CAI/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAEhC,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,sBAAoB,KACnB,OAIF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,GACxB,YAAY,SAAS,WAAW,EAChC,OAAO,SAAS,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAEjD,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,QAAQ,OAAO,KACd,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,GAYtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAC9B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAEhC,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,aAAa,OAAO,EACpB,WAAW,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,KACxC,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,GAAG,SAQnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAEhC,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,cAAW,KACV,SAAS,CAAC,YAAY,EAAE,KAAK,CAa/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,SAAS,WAAW,EAChC,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,EAChC,OAAO,EAEP,SAAS,OAAO,CAAC,YAAY,CAAC,EAC9B,MAAM,KAAK,EACX,UAAU,CAAC,KAAK,EAAE,SAAS,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,OAAO,EAC5D,OAAM,KAAK,CAAC,cAAmB,KAC9B,OAOF,CAAC"}

package/dist/wrappers/AsyncMultiSelect/AsyncMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { FieldPath, FieldValues } from 'react-hook-form';
+import type { AsyncMultiSelectElementProps, OptionObject } from './types';
+declare const AsyncSelectMultiElement: {
+    <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TValueKey extends string = "Value", TLabelKey extends string = "Label", TOption extends OptionObject<TValueKey, TLabelKey> = OptionObject<TValueKey, TLabelKey>>({ gridProps, ...props }: AsyncMultiSelectElementProps<TFieldValues, TName, TValueKey, TLabelKey, TOption>): React.ReactElement;
+    displayName: string;
+};
+export { AsyncSelectMultiElement };
+//# sourceMappingURL=AsyncMultiSelect.d.ts.map

package/dist/wrappers/AsyncMultiSelect/AsyncMultiSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncMultiSelect.d.ts","sourceRoot":"","sources":["../../../src/wrappers/AsyncMultiSelect/AsyncMultiSelect.tsx"],"names":[],"mappings":"AAUA,OAAO,KAON,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAqP1E,QAAA,MAAM,uBAAuB;KAC3B,YAAY,SAAS,WAAW,gBAChC,KAAK,SAAS,SAAS,CAAC,YAAY,CAAC,4BACrC,SAAS,SAAS,MAAM,YACxB,SAAS,SAAS,MAAM,YACxB,OAAO,SAAS,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC,gEAOjD,4BAA4B,CAC7B,YAAY,EACZ,KAAK,EACL,SAAS,EACT,SAAS,EACT,OAAO,CACR,GAAG,KAAK,CAAC,YAAY;;CAgBrB,CAAC;AAIF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/wrappers/AsyncMultiSelect/index.d.ts

@@ -0,0 +1,3 @@
+export { AsyncSelectMultiElement } from './AsyncMultiSelect';
+export type { AsyncMultiSelectElementProps, OptionObject } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/wrappers/AsyncMultiSelect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wrappers/AsyncMultiSelect/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,YAAY,EAAE,4BAA4B,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/wrappers/AsyncMultiSelect/types.d.ts

@@ -0,0 +1,19 @@
+import type { AutocompleteProps, ChipTypeMap, GridProps, TextFieldVariants } from "@mui/material";
+import type { Control, FieldPath, FieldValues, Path } from "react-hook-form";
+import type { AsyncMultiSelectPayload } from "../../types";
+type PrimitiveValue = string | number | boolean;
+export type OptionObject<TValueKey extends string = string, TLabelKey extends string = string> = Record<TValueKey, PrimitiveValue> & Record<TLabelKey, string> & Record<string, unknown>;
+export type AsyncMultiSelectElementProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = Path<TFieldValues>, TValueKey extends string = "Value", TLabelKey extends string = "Label", TOption extends OptionObject<TValueKey, TLabelKey> = OptionObject<TValueKey, TLabelKey>, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false, ChipComponent extends React.ElementType = ChipTypeMap["defaultComponent"]> = Omit<AutocompleteProps<TOption, true, DisableClearable, FreeSolo, ChipComponent>, "name" | "control" | "ref" | "multiple" | "loading" | "getOptionLabel" | "getOptionKey" | "isOptionEqualToValue" | "options" | "value" | "filterSelectedOptions" | "filterOptions" | "onChange" | "onInputChange" | "renderInput"> & {
+    name: TName;
+    control?: Control<TFieldValues>;
+    gridProps?: GridProps;
+    placeholder?: string;
+    label?: string;
+    initialValues?: Array<TOption[TValueKey]> | null;
+    queryFn: (data: AsyncMultiSelectPayload) => Promise<TOption[] | undefined>;
+    variant?: TextFieldVariants;
+    labelField?: TLabelKey;
+    valueField?: TValueKey;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map