@ahoo-wang/fetcher 3.0.2 → 3.0.3

package/dist/types.d.ts

@@ -35,27 +35,149 @@ export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
  */
 export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /**
- * Interface representing a named capable entity
- * Types implementing this interface must provide a name property
+ * Creates a new type by removing all readonly properties from an existing type.
+ *
+ * This utility type takes a type T and produces a new type that excludes all properties
+ * that are marked as readonly in the original type. This is useful when you need to create
+ * a mutable version of an interface or when working with data that should be modifiable.
+ *
+ * @template T - The original type from which to remove readonly properties
+ * @returns A new type containing only the mutable (non-readonly) properties of T
+ *
+ * @example
+ * interface User {
+ *   readonly id: number;
+ *   name: string;
+ *   readonly createdAt: Date;
+ *   email: string;
+ * }
+ *
+ * type MutableUser = RemoveReadonlyFields<User>;
+ * // Result: { name: string; email: string; }
+ * // 'id' and 'createdAt' are excluded because they are readonly
+ *
+ * @example
+ * // Usage in function parameters
+ * function updateUser(user: RemoveReadonlyFields<User>) {
+ *   // user.id and user.createdAt are not available here
+ *   user.name = 'New Name'; // OK
+ *   user.email = 'new@email.com'; // OK
+ * }
+ */
+export type RemoveReadonlyFields<T> = {
+    [K in keyof T as Equal<Pick<T, K>, Readonly<Pick<T, K>>> extends true ? never : K]: T[K];
+};
+/**
+ * Utility type to check if two types X and Y are exactly equal.
+ *
+ * This type uses conditional types and function type inference to determine
+ * strict type equality. It returns true if X and Y are identical types,
+ * false otherwise. This is particularly useful in mapped types for filtering
+ * based on type properties.
+ *
+ * @template X - First type to compare
+ * @template Y - Second type to compare
+ * @returns true if X and Y are the same type, false otherwise
+ *
+ * @internal This is an internal utility type used by other type definitions
+ */
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/**
+ * Interface representing a named capable entity.
+ *
+ * This interface defines a contract for objects that have an identifiable name.
+ * Any type implementing this interface must provide a string property called 'name'
+ * that uniquely identifies the entity within its context.
+ *
+ * @interface NamedCapable
+ *
+ * @property {string} name - A unique identifier for the entity, used for
+ *   identification, logging, and user-facing display purposes.
+ *
+ * @example
+ * class Service implements NamedCapable {
+ *   name = 'UserService';
+ *
+ *   async getUser(id: number) {
+ *     // Implementation
+ *   }
+ * }
+ *
+ * @example
+ * const services: NamedCapable[] = [
+ *   { name: 'AuthService' },
+ *   { name: 'DataService' }
+ * ];
+ *
+ * services.forEach(service => {
+ *   console.log(`Initializing ${service.name}`);
+ * });
  */
 export interface NamedCapable {
     /**
-     * The name of the entity
+     * The name of the entity.
+     *
+     * This property serves as a unique identifier for the implementing object.
+     * It should be descriptive and follow consistent naming conventions
+     * within the application context.
      */
     name: string;
 }
 /**
- * Global extension of Response interface
- * Adds type-safe json() method support to Response objects
+ * Global extension of the native Response interface.
+ *
+ * This declaration augments the standard Web API Response interface to provide
+ * enhanced type safety for JSON parsing operations. The extended json() method
+ * allows specifying the expected return type, enabling better TypeScript
+ * inference and compile-time type checking.
+ *
+ * @interface Response
  */
 declare global {
     interface Response {
         /**
-         * Parse response body as JSON in a type-safe manner
-         * @template T The type of returned data, defaults to any
-         * @returns Promise<T> The parsed JSON data
+         * Parses the response body as JSON with type safety.
+         *
+         * This method extends the native Response.json() method to support generic
+         * type parameters, allowing developers to specify the expected shape of
+         * the parsed JSON data. This provides compile-time type checking and
+         * better IDE support.
+         *
+         * @template T - The expected type of the parsed JSON data. Defaults to 'any' for backward compatibility.
+         * @returns {Promise<T>} A promise that resolves to the parsed JSON data of type T.
+         *
+         * @throws {SyntaxError} If the response body is not valid JSON.
+         * @throws {TypeError} If the response has no body or the body cannot be parsed.
+         *
+         * @example
+         * interface User {
+         *   id: number;
+         *   name: string;
+         *   email: string;
+         * }
+         *
+         * const response = await fetch('/api/user/123');
+         * const user: User = await response.json<User>();
+         * console.log(user.name); // TypeScript knows this is a string
+         *
+         * @example
+         * // Without type parameter (defaults to any)
+         * const data = await response.json();
+         * // data is of type 'any'
+         *
+         * @example
+         * // Error handling
+         * try {
+         *   const result = await response.json<{ success: boolean; data: string[] }>();
+         *   if (result.success) {
+         *     result.data.forEach(item => console.log(item));
+         *   }
+         * } catch (error) {
+         *   console.error('Failed to parse JSON:', error);
+         * }
          */
         json<T = any>(): Promise<T>;
     }
 }
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACvD,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEvB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,QAAQ;QAChB;;;;WAIG;QACH,IAAI,CAAC,CAAC,GAAG,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;KAC7B;CACF"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACvD,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;KACnC,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACjE,KAAK,GACL,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACb,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,IACb,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAC/D,IAAI,GACJ,KAAK,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,QAAQ;QAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwCG;QACH,IAAI,CAAC,CAAC,GAAG,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;KAC7B;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahoo-wang/fetcher",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Fetcher is not just another HTTP client—it's a complete ecosystem designed for modern web development with native LLM\nstreaming API support. Built on the native Fetch API, Fetcher provides an Axios-like experience with powerful features\nwhile maintaining an incredibly small footprint.",
   "keywords": [
     "fetch",