@gnwebsoft/ui 3.0.7 → 4.0.0

package/dist/chunk-BRRLB22L.js

@@ -0,0 +1,72 @@
+// src/types/api.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof FormData);
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isFormData(value) {
+  return value instanceof FormData;
+}
+function isRequestBody(value) {
+  return isJsonObject(value) || isJsonArray(value) || isFormData(value);
+}
+
+// src/types/events.ts
+function isInputChangeEvent(value) {
+  return typeof value === "object" && value !== null && "target" in value && typeof value.target === "object" && value.target !== null && "value" in value.target;
+}
+function isSelectChangeEvent(value) {
+  return isInputChangeEvent(value);
+}
+function isFormChangeEvent(value) {
+  return isInputChangeEvent(value) || isSelectChangeEvent(value);
+}
+function extractEventValue(eventOrValue, fallbackValue) {
+  if (isFormChangeEvent(eventOrValue)) {
+    return eventOrValue.target.value;
+  }
+  if (typeof eventOrValue === "object" && eventOrValue !== null && "target" in eventOrValue && typeof eventOrValue.target === "object" && eventOrValue.target !== null && "value" in eventOrValue.target) {
+    return eventOrValue.target.value;
+  }
+  return eventOrValue ?? fallbackValue;
+}
+function createEventValueExtractor() {
+  return (eventOrValue, directValue) => {
+    if (directValue !== void 0) {
+      return directValue;
+    }
+    return extractEventValue(eventOrValue);
+  };
+}
+
+// src/types/utilities.ts
+function brand(value) {
+  return value;
+}
+function typedKeys(obj) {
+  return Object.keys(obj);
+}
+function typedEntries(obj) {
+  return Object.entries(obj);
+}
+function typedValues(obj) {
+  return Object.values(obj);
+}
+
+export {
+  isJsonObject,
+  isJsonArray,
+  isFormData,
+  isRequestBody,
+  isInputChangeEvent,
+  isSelectChangeEvent,
+  isFormChangeEvent,
+  extractEventValue,
+  createEventValueExtractor,
+  brand,
+  typedKeys,
+  typedEntries,
+  typedValues
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/types/api.ts", "../src/types/events.ts", "../src/types/utilities.ts"],
  "sourcesContent": ["/**\n * Type-safe API request and response utilities\n * @module types/api\n */\n\n/**\n * HTTP methods supported by the API\n */\nexport type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';\n\n/**\n * Valid JSON primitive types that can be sent in request bodies\n */\nexport type JsonPrimitive = string | number | boolean | null;\n\n/**\n * Valid JSON values (primitives, objects, arrays)\n */\nexport type JsonValue =\n  | JsonPrimitive\n  | JsonObject\n  | JsonArray;\n\n/**\n * JSON object with string keys and JSON values\n */\nexport interface JsonObject {\n  [key: string]: JsonValue;\n}\n\n/**\n * JSON array containing JSON values\n */\nexport type JsonArray = JsonValue[];\n\n/**\n * Type-safe request body - must be JSON-serializable\n */\nexport type RequestBody = JsonObject | JsonArray | FormData;\n\n/**\n * Standard HTTP headers with known header names\n */\nexport type HttpHeaders = Record<string, string>;\n\n/**\n * Options for making HTTP requests (based on fetch API)\n */\nexport interface RequestOptions {\n  /**\n   * HTTP method for the request\n   */\n  method: HttpMethod;\n  /**\n   * Request headers\n   */\n  headers?: HttpHeaders;\n  /**\n   * Request body (string for JSON, FormData for file uploads)\n   */\n  body?: string | FormData;\n  /**\n   * Request credentials mode\n   */\n  credentials?: RequestCredentials;\n  /**\n   * Request mode (cors, no-cors, same-origin)\n   */\n  mode?: RequestMode;\n  /**\n   * Cache mode for the request\n   */\n  cache?: RequestCache;\n  /**\n   * Redirect mode for the request\n   */\n  redirect?: RequestRedirect;\n  /**\n   * Referrer policy for the request\n   */\n  referrerPolicy?: ReferrerPolicy;\n  /**\n   * AbortSignal for request cancellation\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Configuration options for API calls\n */\nexport interface ApiCallOptions {\n  /**\n   * Custom headers to include in the request\n   */\n  headers?: HttpHeaders;\n  /**\n   * Whether to include authentication token\n   * @defaultValue true\n   */\n  includeAuth?: boolean;\n  /**\n   * AbortSignal for request cancellation\n   */\n  signal?: AbortSignal;\n  /**\n   * Custom base URL (overrides default)\n   */\n  baseUrl?: string;\n}\n\n/**\n * Options for fetch operations with any additional parameters\n */\nexport interface FetchOptions extends Omit<RequestInit, 'body' | 'headers'> {\n  /**\n   * Request headers\n   */\n  headers?: HttpHeaders;\n  /**\n   * Request body\n   */\n  body?: RequestBody;\n}\n\n/**\n * Type guard to check if a value is a valid JSON object\n */\nexport function isJsonObject(value: unknown): value is JsonObject {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    !Array.isArray(value) &&\n    !(value instanceof FormData)\n  );\n}\n\n/**\n * Type guard to check if a value is a valid JSON array\n */\nexport function isJsonArray(value: unknown): value is JsonArray {\n  return Array.isArray(value);\n}\n\n/**\n * Type guard to check if a value is FormData\n */\nexport function isFormData(value: unknown): value is FormData {\n  return value instanceof FormData;\n}\n\n/**\n * Type guard to check if a value is a valid request body\n */\nexport function isRequestBody(value: unknown): value is RequestBody {\n  return isJsonObject(value) || isJsonArray(value) || isFormData(value);\n}\n", "/**\n * Type-safe DOM event and handler utilities for form transformations\n * @module types/events\n */\n\nimport type { ChangeEvent, SyntheticEvent } from \"react\";\n\n/**\n * HTML input elements that support the onChange event with a value\n */\nexport type InputElement = HTMLInputElement | HTMLTextAreaElement;\n\n/**\n * HTML select element\n */\nexport type HtmlSelectElement = HTMLSelectElement;\n\n/**\n * Standard React change event for input/textarea elements\n */\nexport type InputChangeEvent = ChangeEvent<InputElement>;\n\n/**\n * Standard React change event for select elements\n */\nexport type SelectChangeEvent = ChangeEvent<HtmlSelectElement>;\n\n/**\n * Union of all standard form change events\n */\nexport type FormChangeEvent = InputChangeEvent | SelectChangeEvent;\n\n/**\n * Generic synthetic event from React\n */\nexport type GenericSyntheticEvent = SyntheticEvent<Element>;\n\n/**\n * Value extracted from an event or passed directly\n * This covers MUI's pattern of (event, value) callbacks\n */\nexport type EventOrValue<TValue = unknown> = \n  | TValue \n  | InputChangeEvent \n  | SelectChangeEvent\n  | GenericSyntheticEvent;\n\n/**\n * Transform output handler that accepts various event patterns\n * Supports:\n * - Standard onChange: (event: ChangeEvent) => void\n * - MUI onChange: (event: ChangeEvent, value: T) => void\n * - Direct value: (value: T) => void\n */\nexport type TransformOutputHandler<TValue = unknown> = (\n  eventOrValue: EventOrValue<TValue>,\n  value?: TValue\n) => TValue;\n\n/**\n * Transform input handler that converts a value to display format\n */\nexport type TransformInputHandler<TInput = unknown, TOutput = unknown> = (\n  value: TInput\n) => TOutput;\n\n/**\n * Generic event handler that accepts rest parameters\n * Used for flexibility in event handling\n */\nexport type GenericEventHandler<TReturn = void> = (...args: unknown[]) => TReturn;\n\n/**\n * Type guard to check if a value is an InputChangeEvent\n */\nexport function isInputChangeEvent(value: unknown): value is InputChangeEvent {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'target' in value &&\n    typeof (value as { target: unknown }).target === 'object' &&\n    (value as { target: unknown }).target !== null &&\n    'value' in (value as { target: { value?: unknown } }).target\n  );\n}\n\n/**\n * Type guard to check if a value is a SelectChangeEvent\n */\nexport function isSelectChangeEvent(value: unknown): value is SelectChangeEvent {\n  return isInputChangeEvent(value); // Same structure, different element type\n}\n\n/**\n * Type guard to check if a value is any form change event\n */\nexport function isFormChangeEvent(value: unknown): value is FormChangeEvent {\n  return isInputChangeEvent(value) || isSelectChangeEvent(value);\n}\n\n/**\n * Extract value from event or return the value directly\n * Handles the common pattern: value ?? event?.target?.value ?? event\n */\nexport function extractEventValue<TValue = unknown>(\n  eventOrValue: EventOrValue<TValue>,\n  fallbackValue?: TValue\n): TValue {\n  // If it's a form change event, extract the target value\n  if (isFormChangeEvent(eventOrValue)) {\n    return eventOrValue.target.value as TValue;\n  }\n  \n  // If it has a target.value (but didn't match above guards), try to extract it\n  if (\n    typeof eventOrValue === 'object' &&\n    eventOrValue !== null &&\n    'target' in eventOrValue &&\n    typeof eventOrValue.target === 'object' &&\n    eventOrValue.target !== null &&\n    'value' in eventOrValue.target\n  ) {\n    return (eventOrValue.target as { value: TValue }).value;\n  }\n  \n  // Otherwise, treat it as the value itself\n  return (eventOrValue ?? fallbackValue) as TValue;\n}\n\n/**\n * Create a safe event value extractor with type narrowing\n * Useful for MUI components that pass (event, value) pattern\n */\nexport function createEventValueExtractor<TValue = unknown>() {\n  return (eventOrValue: EventOrValue<TValue>, directValue?: TValue): TValue => {\n    // If a direct value is provided (MUI pattern), use it\n    if (directValue !== undefined) {\n      return directValue;\n    }\n    \n    return extractEventValue(eventOrValue);\n  };\n}\n", "/**\n * Utility types and type helpers for enhanced type safety\n * \n * @packageDocumentation\n */\n\n/**\n * Makes all properties of T required and non-nullable\n * \n * @example\n * ```typescript\n * interface User {\n *   id?: string;\n *   name?: string | null;\n * }\n * \n * type RequiredUser = DeepRequired<User>;\n * // { id: string; name: string }\n * ```\n * \n * @public\n */\nexport type DeepRequired<T> = {\n  [P in keyof T]-?: NonNullable<T[P]>;\n};\n\n/**\n * Makes all properties of T optional\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n * }\n * \n * type PartialUser = DeepPartial<User>;\n * // { id?: string; name?: string }\n * ```\n * \n * @public\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object\n    ? DeepPartial<T[P]>\n    : T[P];\n};\n\n/**\n * Makes all properties of T readonly deeply\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   profile: {\n *     name: string;\n *   };\n * }\n * \n * type ReadonlyUser = DeepReadonly<User>;\n * // { readonly id: string; readonly profile: { readonly name: string } }\n * ```\n * \n * @public\n */\nexport type DeepReadonly<T> = {\n  readonly [P in keyof T]: T[P] extends object\n    ? DeepReadonly<T[P]>\n    : T[P];\n};\n\n/**\n * Extracts keys from T that are not undefined\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name?: string;\n *   email: string | undefined;\n * }\n * \n * type RequiredKeys = RequiredKeys<User>;\n * // 'id'\n * ```\n * \n * @public\n */\nexport type RequiredKeys<T> = {\n  [K in keyof T]-?: undefined extends T[K] ? never : K;\n}[keyof T];\n\n/**\n * Extracts keys from T that can be undefined\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name?: string;\n *   email: string | undefined;\n * }\n * \n * type OptKeys = OptionalKeys<User>;\n * // 'name' | 'email'\n * ```\n * \n * @public\n */\nexport type OptionalKeys<T> = {\n  [K in keyof T]-?: undefined extends T[K] ? K : never;\n}[keyof T];\n\n/**\n * Makes specified keys K of type T required\n * \n * @example\n * ```typescript\n * interface User {\n *   id?: string;\n *   name?: string;\n *   email?: string;\n * }\n * \n * type UserWithId = RequireKeys<User, 'id' | 'email'>;\n * // { id: string; name?: string; email: string }\n * ```\n * \n * @public\n */\nexport type RequireKeys<T, K extends keyof T> = Omit<T, K> &\n  Required<Pick<T, K>>;\n\n/**\n * Makes specified keys K of type T optional\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n *   email: string;\n * }\n * \n * type UserUpdate = PartialKeys<User, 'name' | 'email'>;\n * // { id: string; name?: string; email?: string }\n * ```\n * \n * @public\n */\nexport type PartialKeys<T, K extends keyof T> = Omit<T, K> &\n  Partial<Pick<T, K>>;\n\n/**\n * Excludes keys K from type T\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   password: string;\n *   email: string;\n * }\n * \n * type PublicUser = ExcludeKeys<User, 'password'>;\n * // { id: string; email: string }\n * ```\n * \n * @public\n */\nexport type ExcludeKeys<T, K extends keyof T> = Omit<T, K>;\n\n/**\n * Picks only keys K from type T\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n *   email: string;\n * }\n * \n * type UserCredentials = PickKeys<User, 'email'>;\n * // { email: string }\n * ```\n * \n * @public\n */\nexport type PickKeys<T, K extends keyof T> = Pick<T, K>;\n\n/**\n * Extracts the value type from an array type\n * \n * @example\n * ```typescript\n * type StringArray = string[];\n * type Item = ArrayElement<StringArray>;\n * // string\n * ```\n * \n * @public\n */\nexport type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;\n\n/**\n * Extracts the return type of an async function\n * \n * @example\n * ```typescript\n * async function getUser(): Promise<User> {\n *   return { id: '1', name: 'John' };\n * }\n * \n * type User = AsyncReturnType<typeof getUser>;\n * // User\n * ```\n * \n * @public\n */\nexport type AsyncReturnType<T extends (...args: readonly unknown[]) => Promise<unknown>> =\n  T extends (...args: readonly unknown[]) => Promise<infer R> ? R : never;\n\n/**\n * Makes a type nullable (adds null)\n * \n * @example\n * ```typescript\n * type Username = string;\n * type NullableUsername = Nullable<Username>;\n * // string | null\n * ```\n * \n * @public\n */\nexport type Nullable<T> = T | null;\n\n/**\n * Makes a type optional (adds undefined)\n * \n * @example\n * ```typescript\n * type Username = string;\n * type OptionalUsername = Maybe<Username>;\n * // string | undefined\n * ```\n * \n * @public\n */\nexport type Maybe<T> = T | undefined;\n\n/**\n * Makes a type nullish (adds null and undefined)\n * \n * @example\n * ```typescript\n * type Username = string;\n * type NullishUsername = Nullish<Username>;\n * // string | null | undefined\n * ```\n * \n * @public\n */\nexport type Nullish<T> = T | null | undefined;\n\n/**\n * Creates a union of all possible paths through an object type\n * \n * @example\n * ```typescript\n * interface User {\n *   profile: {\n *     name: string;\n *     address: {\n *       city: string;\n *     };\n *   };\n * }\n * \n * type Paths = ObjectPaths<User>;\n * // 'profile' | 'profile.name' | 'profile.address' | 'profile.address.city'\n * ```\n * \n * @public\n */\nexport type ObjectPaths<T> = {\n  [K in keyof T & string]: T[K] extends object\n    ? K | `${K}.${ObjectPaths<T[K]>}`\n    : K;\n}[keyof T & string];\n\n/**\n * Merges two types, with properties from B overriding those in A\n * \n * @example\n * ```typescript\n * interface A {\n *   id: number;\n *   name: string;\n * }\n * \n * interface B {\n *   id: string;\n *   email: string;\n * }\n * \n * type Merged = Merge<A, B>;\n * // { id: string; name: string; email: string }\n * ```\n * \n * @public\n */\nexport type Merge<A, B> = Omit<A, keyof B> & B;\n\n/**\n * Ensures a type is serializable (no functions, symbols, undefined)\n * \n * @example\n * ```typescript\n * interface Data {\n *   id: string;\n *   callback: () => void;\n *   value: number;\n * }\n * \n * type SerializableData = Serializable<Data>;\n * // { id: string; value: number }\n * ```\n * \n * @public\n */\nexport type Serializable<T> = {\n  [K in keyof T as T[K] extends (...args: readonly unknown[]) => unknown\n    ? never\n    : T[K] extends symbol\n    ? never\n    : T[K] extends undefined\n    ? never\n    : K]: T[K] extends object ? Serializable<T[K]> : T[K];\n};\n\n/**\n * Converts a union type to an intersection type\n * \n * @example\n * ```typescript\n * type Union = { a: string } | { b: number };\n * type Intersection = UnionToIntersection<Union>;\n * // { a: string } & { b: number }\n * ```\n * \n * @public\n */\nexport type UnionToIntersection<U> = (\n  U extends unknown ? (k: U) => void : never\n) extends (k: infer I) => void\n  ? I\n  : never;\n\n/**\n * Gets all keys of T whose values extend V\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   age: number;\n *   name: string;\n *   active: boolean;\n * }\n * \n * type StringKeys = KeysOfType<User, string>;\n * // 'id' | 'name'\n * ```\n * \n * @public\n */\nexport type KeysOfType<T, V> = {\n  [K in keyof T]: T[K] extends V ? K : never;\n}[keyof T];\n\n/**\n * Ensures a value is exactly the type T (no wider types allowed)\n * \n * @example\n * ```typescript\n * const config: Exact<{ debug: boolean }> = {\n *   debug: true,\n *   // extra: 'value'  // \u274C Error: extra property not allowed\n * };\n * ```\n * \n * @public\n */\nexport type Exact<T, Shape = T> = T extends Shape\n  ? Exclude<keyof T, keyof Shape> extends never\n    ? T\n    : never\n  : never;\n\n/**\n * Creates a branded type for nominal typing\n * This prevents mixing values of the same primitive type\n * \n * @example\n * ```typescript\n * type UserId = Brand<string, 'UserId'>;\n * type ProductId = Brand<string, 'ProductId'>;\n * \n * const userId: UserId = '123' as UserId;\n * const productId: ProductId = '456' as ProductId;\n * \n * // \u274C Type error: UserId is not assignable to ProductId\n * const test: ProductId = userId;\n * ```\n * \n * @public\n */\nexport type Brand<T, TBrand extends string> = T & {\n  readonly __brand: TBrand;\n};\n\n/**\n * Helper to create a branded value\n * \n * @param value - The value to brand\n * @returns The value as a branded type\n * \n * @example\n * ```typescript\n * type UserId = Brand<string, 'UserId'>;\n * const id = brand<string, 'UserId'>('user-123');\n * // id has type UserId\n * ```\n * \n * @public\n */\nexport function brand<T, TBrand extends string>(value: T): Brand<T, TBrand> {\n  return value as Brand<T, TBrand>;\n}\n\n/**\n * Removes branding from a branded type\n * \n * @example\n * ```typescript\n * type UserId = Brand<string, 'UserId'>;\n * type PlainId = Unbrand<UserId>;\n * // string\n * ```\n * \n * @public\n */\nexport type Unbrand<T> = T extends infer U & { readonly __brand: string } ? U : T;\n\n/**\n * Type-safe Object.keys that preserves key types\n * \n * @param obj - The object to get keys from\n * @returns Array of keys with proper type\n * \n * @example\n * ```typescript\n * const user = { id: '1', name: 'John' } as const;\n * const keys = typedKeys(user);\n * // keys has type: ('id' | 'name')[]\n * ```\n * \n * @public\n */\nexport function typedKeys<T extends Record<string, unknown>>(\n  obj: T\n): Array<keyof T> {\n  return Object.keys(obj) as Array<keyof T>;\n}\n\n/**\n * Type-safe Object.entries that preserves key and value types\n * \n * @param obj - The object to get entries from\n * @returns Array of [key, value] tuples with proper types\n * \n * @example\n * ```typescript\n * const user = { id: '1', age: 30 } as const;\n * const entries = typedEntries(user);\n * // entries has type: ['id', '1'] | ['age', 30]\n * ```\n * \n * @public\n */\nexport function typedEntries<T extends Record<string, unknown>>(\n  obj: T\n): Array<[keyof T, T[keyof T]]> {\n  return Object.entries(obj) as Array<[keyof T, T[keyof T]]>;\n}\n\n/**\n * Type-safe Object.values that preserves value types\n * \n * @param obj - The object to get values from\n * @returns Array of values with proper type\n * \n * @example\n * ```typescript\n * const user = { id: '1', age: 30 };\n * const values = typedValues(user);\n * // values has type: (string | number)[]\n * ```\n * \n * @public\n */\nexport function typedValues<T extends Record<string, unknown>>(\n  obj: T\n): Array<T[keyof T]> {\n  return Object.values(obj) as Array<T[keyof T]>;\n}\n"],
  "mappings": ";AA+HO,SAAS,aAAa,OAAqC;AAChE,SACE,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,KAAK,KACpB,EAAE,iBAAiB;AAEvB;AAKO,SAAS,YAAY,OAAoC;AAC9D,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAKO,SAAS,WAAW,OAAmC;AAC5D,SAAO,iBAAiB;AAC1B;AAKO,SAAS,cAAc,OAAsC;AAClE,SAAO,aAAa,KAAK,KAAK,YAAY,KAAK,KAAK,WAAW,KAAK;AACtE;;;AChFO,SAAS,mBAAmB,OAA2C;AAC5E,SACE,OAAO,UAAU,YACjB,UAAU,QACV,YAAY,SACZ,OAAQ,MAA8B,WAAW,YAChD,MAA8B,WAAW,QAC1C,WAAY,MAA0C;AAE1D;AAKO,SAAS,oBAAoB,OAA4C;AAC9E,SAAO,mBAAmB,KAAK;AACjC;AAKO,SAAS,kBAAkB,OAA0C;AAC1E,SAAO,mBAAmB,KAAK,KAAK,oBAAoB,KAAK;AAC/D;AAMO,SAAS,kBACd,cACA,eACQ;AAER,MAAI,kBAAkB,YAAY,GAAG;AACnC,WAAO,aAAa,OAAO;AAAA,EAC7B;AAGA,MACE,OAAO,iBAAiB,YACxB,iBAAiB,QACjB,YAAY,gBACZ,OAAO,aAAa,WAAW,YAC/B,aAAa,WAAW,QACxB,WAAW,aAAa,QACxB;AACA,WAAQ,aAAa,OAA6B;AAAA,EACpD;AAGA,SAAQ,gBAAgB;AAC1B;AAMO,SAAS,4BAA8C;AAC5D,SAAO,CAAC,cAAoC,gBAAiC;AAE3E,QAAI,gBAAgB,QAAW;AAC7B,aAAO;AAAA,IACT;AAEA,WAAO,kBAAkB,YAAY;AAAA,EACvC;AACF;;;ACwSO,SAAS,MAAgC,OAA4B;AAC1E,SAAO;AACT;AA+BO,SAAS,UACd,KACgB;AAChB,SAAO,OAAO,KAAK,GAAG;AACxB;AAiBO,SAAS,aACd,KAC8B;AAC9B,SAAO,OAAO,QAAQ,GAAG;AAC3B;AAiBO,SAAS,YACd,KACmB;AACnB,SAAO,OAAO,OAAO,GAAG;AAC1B;",
  "names": []
}
