fastapi-rtk 2.1.4 → 2.2.0

package/dist/utils/esm/mergeProps/mergeProps.mjs

@@ -1,6 +1,13 @@
 import { deepMerge } from "../deepMerge/deepMerge.mjs";
 import { getByPath } from "../getByPath/getByPath.mjs";
-const mergeProps = (obj, ...keys) => deepMerge(...keys.map((key) => getByPath(obj, key)));
+function mergeProps(obj, ...keys) {
+  return deepMerge(
+    ...keys.map((key) => {
+      const value = getByPath(obj, key);
+      return value && typeof value === "object" ? value : void 0;
+    })
+  );
+}
 export {
   mergeProps
 };

package/dist/utils/esm/parseResponse/parseResponse.mjs

@@ -8,9 +8,9 @@ const parseResponse = async (response) => {
   }
   if (!response.ok) {
     if (typeof newData === "object") {
-      throw new Error(
-        typeof (newData.detail ?? newData.message) === "string" ? newData.detail ?? newData.message : JSON.stringify(newData, void 0, 2)
-      );
+      const errorObj = newData;
+      const message = errorObj.detail ?? errorObj.message;
+      throw new Error(typeof message === "string" ? message : JSON.stringify(newData, void 0, 2));
     }
     throw new Error(newData);
   }

package/dist/utils/esm/urlJoin/urlJoin.mjs

@@ -39,8 +39,7 @@ function normalize(strArray) {
   return str;
 }
 function urlJoin(...args) {
-  const parts = Array.from(Array.isArray(args[0]) ? args[0] : args);
-  return normalize(parts);
+  return normalize(args.flat());
 }
 export {
   normalize,

package/dist/utils/lib/FastAPIRTKLogger/FastAPIRTKLogger.d.ts

@@ -1,6 +1,8 @@
-export namespace FastAPIRTKLogger {
-    function log(...args: any[]): void;
-    function error(...args: any[]): void;
-    function warn(...args: any[]): void;
-    function debug(...args: any[]): void;
-}
+type ConsoleArgs = unknown[];
+export declare const FastAPIRTKLogger: {
+    log: (...args: ConsoleArgs) => void;
+    error: (...args: ConsoleArgs) => void;
+    warn: (...args: ConsoleArgs) => void;
+    debug: (...args: ConsoleArgs) => void;
+};
+export {};

package/dist/utils/lib/Memoizer/MemoWrapper.d.ts

@@ -1,9 +1,11 @@
+import { ReactNode } from 'react';
+interface MemoWrapperProps {
+    children?: ReactNode;
+    componentName?: string;
+    [key: string]: unknown;
+}
 /**
- * A wrapper component that memoizes its children based on a shallow comparison of props.
- * This is useful for preventing unnecessary re-renders of child components when the props have not changed.
- * @param {Object} props - The props passed to the MemoWrapper component.
- * @param {React.ReactNode} props.children - The child components to be rendered inside the MemoWrapper.
- * @param {string} [props.componentName] - An optional name for the component being wrapped, used for debugging purposes.
- * @returns {React.ReactNode} The memoized child components.
+ * Memoizes its children by comparing its non-children props, skipping re-renders when they are unchanged.
  */
-export const MemoWrapper: import('react').NamedExoticComponent<object>;
+export declare const MemoWrapper: import('react').MemoExoticComponent<(props: MemoWrapperProps) => ReactNode>;
+export {};

package/dist/utils/lib/Memoizer/MemoWrapper.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/lib/Memoizer/RenderWrapper.d.ts

@@ -1,10 +1,12 @@
+import { ReactNode } from 'react';
+interface RenderWrapperProps {
+    children?: ReactNode;
+    componentName?: string;
+    render?: boolean;
+    [key: string]: unknown;
+}
 /**
- * A wrapper component that conditionally renders its children based on a render prop.
- * This is useful for controlling when child components should be re-rendered based on a specific condition.
- * @param {Object} props - The props passed to the RenderWrapper component.
- * @param {React.ReactNode} props.children - The child components to be rendered inside the RenderWrapper.
- * @param {string} [props.componentName] - An optional name for the component being wrapped, used for debugging purposes.
- * @param {boolean} props.render - A boolean prop that determines whether to render the children or return the previous children.
- * @returns {React.ReactNode} The child components if render is true, otherwise the previous child components.
+ * Conditionally re-renders its children based on a `render` prop.
  */
-export const RenderWrapper: import('react').NamedExoticComponent<object>;
+export declare const RenderWrapper: import('react').MemoExoticComponent<(props: RenderWrapperProps) => ReactNode>;
+export {};

package/dist/utils/lib/Memoizer/RenderWrapper.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/lib/convertId/convertId.d.ts

@@ -1 +1,16 @@
-export function convertId(value: Record<string, any> | string | number | string[] | number[]): string;
+type ConvertIdInput = string | number | boolean | null | undefined | readonly (string | number)[] | object;
+/**
+ * Converts an identifier to a string, particularly for composite keys.
+ *
+ * If the value is an object:
+ * - An Array's elements are joined with a comma.
+ * - Otherwise it is stringified to JSON.
+ *
+ * Non-object values are returned unchanged.
+ *
+ * @param value - The identifier to convert, which can be a primitive or a composite key object.
+ * @returns The converted string for composite keys, or the original value if it's not an object.
+ */
+export declare function convertId(value: string | number | readonly (string | number)[]): string | number;
+export declare function convertId(value: ConvertIdInput): string | number | boolean | null | undefined;
+export {};

package/dist/utils/lib/convertToFormData/convertToFormData.d.ts

@@ -1 +1,15 @@
-export function convertToFormData(data: Record<string, any>): FormData;
+/**
+ * Converts a plain object to a FormData instance.
+ *
+ * - If the value is an array:
+ *   - An empty array appends a null.
+ *   - Otherwise the array is split into Files and non-Files.
+ *     - Each File is appended separately under the same key.
+ *     - Non-File values are appended as a JSON string.
+ * - An object (excluding File) is appended as a JSON string.
+ * - Otherwise the value is appended as-is.
+ *
+ * @param data - The object containing key-value pairs to be converted.
+ * @returns A FormData instance populated with the processed data.
+ */
+export declare const convertToFormData: <T extends object>(data: T) => FormData;

package/dist/utils/lib/createFetchParams/createFetchParams.d.ts

@@ -1,10 +1,23 @@
-export function createFetchParams({ path, method, body, queryParams, options: userOptions }: {
-    path: any;
-    method: any;
-    body?: any;
-    queryParams?: any;
-    options: any;
-}): {
-    fetchPath: any;
-    options: any;
+import { QueryParams } from 'fastapi-rtk/api-types';
+type FetchOptions = Omit<RequestInit, 'headers'> & {
+    headers?: {
+        [name: string]: string;
+    };
 };
+interface CreateFetchParamsArgs {
+    path: string;
+    method: string;
+    body?: Record<string, any>;
+    queryParams?: QueryParams;
+    options?: FetchOptions;
+}
+interface CreateFetchParamsResult {
+    fetchPath: string;
+    options: Omit<RequestInit, 'headers'> & {
+        headers: {
+            [name: string]: string;
+        };
+    };
+}
+export declare function createFetchParams(args: CreateFetchParamsArgs): CreateFetchParamsResult;
+export {};

package/dist/utils/lib/createSafeContext/createSafeContext.d.ts

@@ -1,14 +1,13 @@
-export function createSafeContext(errorMessage: string): [React.ComponentType<{
-    value: any;
-    children: any;
-}>, (options?: SafeContextOptions) => any];
-export type SafeContextOptions = {
-    /**
-     * - Whether to throw an error if the context is not provided.
-     */
+export interface SafeContextOptions<T> {
+    /** Whether to throw an error if the context is not provided. */
     throwOnError?: boolean;
-    /**
-     * - The default value to return if the context is not provided.
-     */
-    defaultValue?: any;
-};
+    /** The value to return if the context is not provided. */
+    defaultValue?: T;
+}
+/**
+ * Create a safe context that throws an error if the context is not provided.
+ *
+ * @param errorMessage - The error message to throw if the context is not provided.
+ * @returns The context provider and a hook to read the context.
+ */
+export declare const createSafeContext: <T>(errorMessage: string) => readonly [import('react').Provider<T | null>, (options?: SafeContextOptions<T>) => T];

package/dist/utils/lib/deepMerge/deepMerge.d.ts

@@ -1 +1,13 @@
-export function deepMerge(...objects: Record<string, any>[]): Record<string, any>;
+import { DeepMerged } from './types';
+/**
+ * Deeply merges multiple objects into a single object.
+ *
+ * @param objects - The objects to be merged.
+ * @returns The merged result object.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 }, e: 4 };
+ * const result = deepMerge(obj1, obj2); // result is { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ */
+export declare function deepMerge<Sources extends readonly (object | null | undefined)[]>(...sources: Sources): DeepMerged<Sources>;

package/dist/utils/lib/deepMerge/index.d.ts

@@ -1 +1,2 @@
 export * from './deepMerge';
+export * from './types';

package/dist/utils/lib/deepMerge/types.d.ts

@@ -0,0 +1,20 @@
+type AnySource = object | null | undefined;
+/** Flattens a computed object type so the language server shows the merged literal, not `DeepMergeTwo<A, B>`. */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** True only for plain objects: excludes arrays/tuples and functions (which `deepMerge` treats as leaves). */
+type IsPlainObject<T> = T extends object ? T extends readonly unknown[] ? false : T extends (...args: never[]) => unknown ? false : true : false;
+/**
+ * Merges two sources into one flat object whose keys are the union of both. Overlapping keys take the
+ * right-hand value, except when both sides are plain objects (recurse) and except `ref` (always last-wins).
+ */
+type DeepMergeTwo<A, B> = Prettify<{
+    [K in keyof A | keyof B]: K extends keyof B ? K extends keyof A ? K extends 'ref' ? B[K] : IsPlainObject<A[K]> extends true ? IsPlainObject<B[K]> extends true ? DeepMergeTwo<A[K], B[K]> : B[K] : B[K] : B[K] : K extends keyof A ? A[K] : never;
+}>;
+/**
+ * Result of `deepMerge(...sources)`: the sources folded left-to-right, last-wins for scalars/arrays/`ref`,
+ * recursive for plain objects. `null` / `undefined` sources are skipped.
+ */
+export type DeepMerged<Sources extends readonly AnySource[]> = Sources extends readonly [infer Head, ...infer Tail] ? Tail extends readonly AnySource[] ? [Head] extends [null | undefined] ? DeepMerged<Tail> : Tail extends readonly [] ? Head : DeepMergeTwo<Head extends object ? Head : Record<never, never>, DeepMerged<Tail>> : Record<never, never> : Record<never, never>;
+export {};

package/dist/utils/lib/getByPath/getByPath.d.ts

@@ -1 +1,13 @@
-export function getByPath(obj: Record<string, any>, path: string, separator?: string): any;
+/**
+ * Retrieves a nested value from an object using a string path.
+ *
+ * @param obj - The object to search within.
+ * @param path - The string path indicating the property to retrieve (e.g., "a.b.c").
+ * @param separator - The separator used to split the path (defaults to '.').
+ * @returns The value found at the specified path, or undefined if any part of the path is not found.
+ *
+ * @example
+ * const obj = { a: { b: { c: 42 } } };
+ * const value = getByPath(obj, 'a.b.c'); // value is 42
+ */
+export declare const getByPath: (obj: object, path: string, separator?: string) => unknown;

package/dist/utils/lib/getItemId/getItemId.d.ts

@@ -1 +1,13 @@
-export function getItemId(item: Record<string, any>): (string | number | undefined);
+import { PrimaryKey } from 'fastapi-rtk/api-types';
+/**
+ * Retrieves the item's identifier, preferring the 'id_' property and falling back to 'id'.
+ *
+ * @param item - The item object from which to retrieve the identifier.
+ * @returns The identifier from the item, or undefined if neither property exists.
+ */
+interface ItemLike {
+    id_?: PrimaryKey | null;
+    id?: PrimaryKey | null;
+}
+export declare const getItemId: (item: ItemLike | null | undefined) => PrimaryKey | undefined;
+export {};

package/dist/utils/lib/getItemName/getItemName.d.ts

@@ -1 +1,12 @@
-export function getItemName(item: Record<string, any>): string | undefined;
+/**
+ * Retrieves the item's name, preferring the "name_" property and falling back to "_name".
+ *
+ * @param item - The item object that may contain a name.
+ * @returns The name from the item if it exists; otherwise, undefined.
+ */
+interface ItemLike {
+    name_?: string;
+    _name?: string;
+}
+export declare const getItemName: (item: ItemLike | null | undefined) => string | undefined;
+export {};

package/dist/utils/lib/getValue/getValue.d.ts

@@ -1 +1,10 @@
-export function getValue(entry: Record<string, any>, column: string, parse?: boolean): string | Record<string, any>;
+/**
+ * Retrieves the value from an entry object based on the specified column path.
+ * Handles nested fields and one-to-many relationships using dot notation.
+ *
+ * @param entry - The entry object from which to retrieve the value.
+ * @param column - The column path, which can include dot notation for nested fields.
+ * @param parse - Whether to parse the retrieved value. Defaults to true.
+ * @returns The retrieved value, or a concatenated string if the field is a one-to-many relationship.
+ */
+export declare const getValue: (entry: object | null | undefined, column: string, parse?: boolean) => unknown;

package/dist/utils/lib/getValueOrDefault/getValueOrDefault.d.ts

@@ -1 +1,8 @@
-export function getValueOrDefault(value: any, defaultValue: any): any;
+/**
+ * Returns the provided value if it is not undefined, otherwise returns the default value.
+ *
+ * @param value - The value to check.
+ * @param defaultValue - The default value to return if the provided value is undefined.
+ * @returns The provided value if it is not undefined, otherwise the default value.
+ */
+export declare const getValueOrDefault: <T>(value: T | undefined, defaultValue: T) => T;

package/dist/utils/lib/isTruthy/isTruthy.d.ts

@@ -1,9 +1,7 @@
 /**
- * Checks if a value is truthy.
+ * Checks if a value is neither `undefined` nor `null`.
  *
- * A value is considered truthy if it is not `undefined` and not `null`.
- *
- * @param {*} value - The value to check.
- * @returns {boolean} - Returns `true` if the value is truthy, otherwise `false`.
+ * @param value - The value to check.
+ * @returns `true` if the value is neither `undefined` nor `null`, otherwise `false`.
  */
-export function isTruthy(value: any): boolean;
+export declare function isTruthy<T>(value: T): value is NonNullable<T>;

package/dist/utils/lib/mergeProps/index.d.ts

@@ -1 +1,2 @@
 export * from './mergeProps';
+export * from './types';

package/dist/utils/lib/mergeProps/mergeProps.d.ts

@@ -1 +1,13 @@
-export function mergeProps(obj: Record<string, any>, ...keys: string[]): Record<string, any>;
+import { MergedProps } from './types';
+/**
+ * Extracts values from the object at the given key paths via `getByPath` and deep merges them via `deepMerge`.
+ *
+ * @param obj - The source object from which to extract properties.
+ * @param keys - The property paths to be extracted and merged.
+ * @returns The deep merged result of the extracted properties.
+ *
+ * @example
+ * const obj = {a: {b: {c: 1}}, x: {y: {z: 2}}};
+ * const result = mergeProps(obj, 'a.b', 'x.y'); // result will be {c: 1, z: 2}
+ */
+export declare function mergeProps<Obj extends object, const Paths extends readonly string[]>(obj: Obj, ...keys: Paths): MergedProps<Obj, Paths>;

package/dist/utils/lib/mergeProps/types.d.ts

@@ -0,0 +1,14 @@
+import { DeepMerged } from '../deepMerge';
+/** Resolves a dot-path string (e.g. `"a.b.c"`) to the value type at that path, or `undefined` if absent. */
+export type PathValue<Obj, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Obj ? PathValue<NonNullable<Obj[Head]>, Rest> : undefined : Path extends keyof Obj ? Obj[Path] : undefined;
+/** Narrows a resolved path value to something `deepMerge` accepts; non-objects contribute nothing. */
+export type AsSource<T> = T extends object ? T : undefined;
+/** Forces the language server to display the merged object literal instead of the alias expression. */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** Result of `mergeProps(obj, ...paths)`: the value at each path, deep-merged left-to-right. */
+export type MergedProps<Obj, Paths extends readonly string[]> = Simplify<DeepMerged<{
+    [I in keyof Paths]: AsSource<PathValue<Obj, Paths[I]>>;
+}>>;
+export {};

package/dist/utils/lib/parseFromValuesOrFunc/parseFromValuesOrFunc.d.ts

@@ -1 +1,8 @@
-export function parseFromValuesOrFunc(valueOrFunction: any | Function, arg: any): any;
+/**
+ * Resolves a value that may be provided directly or via a factory function.
+ *
+ * @param valueOrFunction - The value, or a function that returns the value.
+ * @param arg - The argument passed to the function when `valueOrFunction` is a function.
+ * @returns The resolved value.
+ */
+export declare const parseFromValuesOrFunc: <Value, Arg>(valueOrFunction: Value | ((arg: Arg) => Value), arg?: Arg) => Value;

package/dist/utils/lib/parseResponse/parseResponse.d.ts

@@ -1 +1,18 @@
-export function parseResponse(response: Response): Promise<Record<string, any> | string>;
+interface ParseableResponse {
+    ok: boolean;
+    headers: {
+        get(name: string): string | null | undefined;
+    };
+    json(): Promise<object | string>;
+    text(): Promise<string>;
+}
+/**
+ * Parses an HTTP response as JSON or text based on its content type.
+ *
+ * @param response - The HTTP response object from the fetch API.
+ * @returns A promise that resolves with the parsed data, either as an object or a string.
+ * @throws Throws an error if the response is not ok. The error message is derived from the parsed data,
+ * using the "detail" or "message" property if available on an object, or by stringifying the object or using the text directly.
+ */
+export declare const parseResponse: (response: ParseableResponse) => Promise<object | string>;
+export {};

package/dist/utils/lib/parseValue/parseValue.d.ts

@@ -1 +1,7 @@
-export function parseValue(value: any): string | null;
+/**
+ * Returns a string representation of the value.
+ *
+ * @param value - The value to be parsed. Can be of any type.
+ * @returns The parsed value as a string, or the value unchanged for null/undefined/number/string.
+ */
+export declare const parseValue: (value: any) => string | number | null | undefined;

package/dist/utils/lib/urlJoin/urlJoin.d.ts

@@ -1,2 +1,2 @@
-export function normalize(strArray: any): string;
-export function urlJoin(...args: any[]): string;
+export declare function normalize(strArray: string[]): string;
+export declare function urlJoin(...args: [string[]] | string[]): string;

package/dist/utils/lib/useWatchRef/useWatchRef.d.ts

@@ -1 +1,10 @@
-export function useWatchRef(ref: React.RefObject<any>, callback?: (newValue: any) => void): any;
+import { RefObject } from 'react';
+/**
+ * Watches a ref and re-renders when its value changes. Checks once per frame via
+ * requestAnimationFrame, which is more efficient than setInterval.
+ *
+ * @param ref - The ref to watch for changes.
+ * @param callback - Optional callback invoked whenever the ref's value changes, receiving the new value.
+ * @returns The current value of the ref. The component re-renders whenever the ref's value changes.
+ */
+export declare const useWatchRef: <T>(ref: RefObject<T> | null | undefined, callback?: (newValue: T) => void) => T | undefined;

package/dist/zustand/cjs/utils/compareStateWithStore.cjs

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const compareStateWithStore = (state, obj) => Object.entries(obj).reduce((acc, [key, value]) => {
+  const stateValue = state[key];
   if (typeof value === "object") {
-    if (JSON.stringify(value) === JSON.stringify(state[key])) {
+    if (JSON.stringify(value) === JSON.stringify(stateValue)) {
       return acc;
     }
   }
-  if (value === state[key]) {
+  if (value === stateValue) {
     return acc;
   }
   return { ...acc, [key]: value };

package/dist/zustand/cjs/utils/createProxy.cjs

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const createProxy = (store, directProperties = []) => new Proxy(store, {
   get(target, prop) {
-    if (directProperties.includes(prop)) {
+    if (typeof prop === "string" && directProperties.includes(prop)) {
       return target[prop];
     }
-    return target((state) => state[prop]);
+    return target((state) => state[String(prop)]);
   },
   ownKeys(target) {
     return Reflect.ownKeys(target.getState());
@@ -13,5 +13,6 @@ const createProxy = (store, directProperties = []) => new Proxy(store, {
   getOwnPropertyDescriptor(target, prop) {
     return Reflect.getOwnPropertyDescriptor(target.getState(), prop);
   }
+  // #MUSTASSERT #MUSTUNKNOWN the Proxy synthesizes a state-shaped view of the store #MUSTUNKNOWN and cannot be statically typed
 });
 exports.createProxy = createProxy;

package/dist/zustand/esm/utils/compareStateWithStore.mjs

@@ -1,10 +1,11 @@
 const compareStateWithStore = (state, obj) => Object.entries(obj).reduce((acc, [key, value]) => {
+  const stateValue = state[key];
   if (typeof value === "object") {
-    if (JSON.stringify(value) === JSON.stringify(state[key])) {
+    if (JSON.stringify(value) === JSON.stringify(stateValue)) {
       return acc;
     }
   }
-  if (value === state[key]) {
+  if (value === stateValue) {
     return acc;
   }
   return { ...acc, [key]: value };

package/dist/zustand/esm/utils/createProxy.mjs

@@ -1,9 +1,9 @@
 const createProxy = (store, directProperties = []) => new Proxy(store, {
   get(target, prop) {
-    if (directProperties.includes(prop)) {
+    if (typeof prop === "string" && directProperties.includes(prop)) {
       return target[prop];
     }
-    return target((state) => state[prop]);
+    return target((state) => state[String(prop)]);
   },
   ownKeys(target) {
     return Reflect.ownKeys(target.getState());
@@ -11,6 +11,7 @@ const createProxy = (store, directProperties = []) => new Proxy(store, {
   getOwnPropertyDescriptor(target, prop) {
     return Reflect.getOwnPropertyDescriptor(target.getState(), prop);
   }
+  // #MUSTASSERT #MUSTUNKNOWN the Proxy synthesizes a state-shaped view of the store #MUSTUNKNOWN and cannot be statically typed
 });
 export {
   createProxy

package/dist/zustand/lib/useProxy/useProxy.d.ts

@@ -1,11 +1,9 @@
+import { StoreApi } from '../../../.external/lib/zustand';
 /**
- * Custom hook that creates a proxy for a given object and synchronizes it with a store.
- *
- * @param {Record<string, any>} obj - The object to be proxied.
- * @returns {Record<string, any>} - The proxy object.
+ * Creates a proxy for an object and synchronizes it with a store.
  *
  * @example
  * const proxy = useProxy({ key: 'value' });
  * console.log(proxy.key); // 'value'
  */
-export function useProxy(obj: Record<string, any>): Record<string, any>;
+export declare function useProxy<T extends object>(obj: T): T & Pick<StoreApi<T>, 'getState' | 'setState'>;

package/dist/zustand/lib/utils/compareStateWithStore.d.ts

@@ -1 +1,5 @@
-export function compareStateWithStore(state: Record<string, any>, obj: Record<string, any>): Record<string, any>;
+/**
+ * Returns the entries of `obj` that differ from `state`. Object values are compared by their
+ * JSON string representations; primitive values are compared directly.
+ */
+export declare const compareStateWithStore: <T extends object>(state: T, obj: T) => Partial<T>;

package/dist/zustand/lib/utils/createProxy.d.ts

@@ -1 +1,12 @@
-export function createProxy(store: any, directProperties?: string[]): ProxyConstructor;
+import { StoreApi, UseBoundStore } from '../../../.external/lib/zustand';
+/**
+ * Creates a proxy for the given zustand store.
+ *
+ * Each state field is read through the store's selector signature; the names in
+ * `directProperties` (e.g. `getState`, `setState`) are read straight off the store instead.
+ *
+ * @param store - The store to be proxied.
+ * @param directProperties - Properties read directly off the store rather than its state.
+ * @returns A proxy over the store's state.
+ */
+export declare const createProxy: <T extends object>(store: UseBoundStore<StoreApi<T>>, directProperties?: string[]) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastapi-rtk",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "private": false,
   "description": "A React component library for FastAPI in combination with FastAPI React Toolkit backend, built with Mantine, JsonForms, and Zustand.",
   "license": "MIT",
@@ -33,11 +33,26 @@
     "./dist/style.css": "./dist/core/styles.css",
     "./styles.css": "./dist/core/styles.css",
     "./dist/styles.css": "./dist/core/styles.css",
+    "./api-types": {
+      "types": "./dist/api-types/lib/index.d.ts",
+      "import": "./dist/api-types/esm/index.mjs",
+      "require": "./dist/api-types/cjs/index.cjs"
+    },
+    "./components": {
+      "types": "./dist/components/lib/index.d.ts",
+      "import": "./dist/components/esm/index.mjs",
+      "require": "./dist/components/cjs/index.cjs"
+    },
     "./constants": {
       "types": "./dist/constants/lib/index.d.ts",
       "import": "./dist/constants/esm/index.mjs",
       "require": "./dist/constants/cjs/index.cjs"
     },
+    "./contexts": {
+      "types": "./dist/contexts/lib/index.d.ts",
+      "import": "./dist/contexts/esm/index.mjs",
+      "require": "./dist/contexts/cjs/index.cjs"
+    },
     "./core": {
       "types": "./dist/core/lib/index.d.ts",
       "import": "./dist/core/esm/index.mjs",
@@ -135,6 +150,8 @@
     "test:coverage:merge": "pnpm test:coverage && node scripts/merge-coverage.mjs",
     "build": "[ -d dist ] && rm -r dist; pnpm -r build",
     "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build"
+    "build-storybook": "storybook build",
+    "typecheck": "pnpm -r --if-present typecheck && node scripts/check-escape-hatches.mjs",
+    "check:escape-hatches": "node scripts/check-escape-hatches.mjs"
   }
 }

package/dist/core/cjs/hooks/api/useApi.cjs

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ApiContext = require("../../Wrappers/ApiProvider/Contexts/ApiContext.cjs");
-const useApi = (options) => ApiContext.useApiProvider(options);
-exports.useApi = useApi;

package/dist/core/cjs/hooks/lang/useLang.cjs

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const LangContext = require("../../Wrappers/Provider/Contexts/LangContext.cjs");
-const useLang = (options) => LangContext.useLangProvider(options);
-exports.useLang = useLang;

package/dist/core/esm/Wrappers/ApiProvider/Contexts/ApiContext.mjs

@@ -1,6 +0,0 @@
-import { createSafeContext } from "fastapi-rtk/utils";
-const [ApiContextProvider, useApiProvider] = createSafeContext("useApi must be used within an ApiProvider");
-export {
-  ApiContextProvider,
-  useApiProvider
-};

package/dist/core/esm/hooks/api/useApi.mjs

@@ -1,5 +0,0 @@
-import { useApiProvider } from "../../Wrappers/ApiProvider/Contexts/ApiContext.mjs";
-const useApi = (options) => useApiProvider(options);
-export {
-  useApi
-};

package/dist/core/esm/hooks/lang/useLang.mjs

@@ -1,5 +0,0 @@
-import { useLangProvider } from "../../Wrappers/Provider/Contexts/LangContext.mjs";
-const useLang = (options) => useLangProvider(options);
-export {
-  useLang
-};