@aarthiklabs/credit-sdk 0.0.1 → 0.0.3-1

package/dist/components/index.d.cts

@@ -1 +1 @@
-export {};
+export { Shell as AarthikShell } from "./layout/shell";

package/dist/components/index.d.ts

@@ -1 +1 @@
-export {};
+export { Shell as AarthikShell } from "./layout/shell";

package/dist/components/layout/constants.d.ts

@@ -0,0 +1,13 @@
+declare const constants: {
+    styles: {
+        dialog: {
+            expanded: string;
+            compacted: string;
+        };
+        drawer: {
+            expanded: string;
+            compacted: string;
+        };
+    };
+};
+export default constants;

package/dist/components/layout/iframe.d.ts

@@ -0,0 +1 @@
+export declare function IFrame({ className }: React.ComponentProps<"iframe">): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/shell.d.ts

@@ -0,0 +1,2 @@
+import type { TypeOfShellProperties } from "./types";
+export declare function Shell({ triggerProperties, title, fullscreen, }: TypeOfShellProperties): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/types.d.ts

@@ -0,0 +1,30 @@
+import type { JSX } from "react";
+type TypeOfShellTriggerProperties = {
+    label: string;
+    component?: never;
+} | {
+    label?: never;
+    component: JSX.Element;
+};
+type TypeOfShellProperties = {
+    triggerProperties: TypeOfShellTriggerProperties;
+    title: string;
+    fullscreen?: "all" | "mobile-only" | "desktop-only" | "none";
+};
+type TypeOfWithDialogProperties = Omit<TypeOfShellProperties, "fullscreen"> & {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    loading: boolean;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    isFullScreen: boolean;
+    setIsFullScreen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+type TypeOfWithDrawerProperties = Omit<TypeOfShellProperties, "fullscreen"> & {
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    loading: boolean;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    isFullScreen: boolean;
+    setIsFullScreen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export type { TypeOfShellProperties, TypeOfShellTriggerProperties, TypeOfWithDialogProperties, TypeOfWithDrawerProperties, };

package/dist/components/layout/with-dialog.d.ts

@@ -0,0 +1,2 @@
+import type { TypeOfWithDialogProperties } from "./types";
+export declare function WithDialog({ open, setOpen, loading, setLoading, isFullScreen, setIsFullScreen, triggerProperties: { label: triggerLabel, component: triggerComponent, }, title, }: TypeOfWithDialogProperties): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/with-drawer.d.ts

@@ -0,0 +1,2 @@
+import type { TypeOfWithDrawerProperties } from "./types";
+export declare function WithDrawer({ open, setOpen, loading, setLoading, isFullScreen, setIsFullScreen, triggerProperties: { label: triggerLabel, component: triggerComponent, }, title, }: TypeOfWithDrawerProperties): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/button.d.ts

@@ -0,0 +1,8 @@
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "xs" | "sm" | "lg" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, ...props }: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+declare function Dialog({ ...props }: DialogPrimitive.Root.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: React.ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/components/ui/drawer.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { Drawer as DrawerPrimitive } from "vaul";
+declare function Drawer({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerPortal({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerClose({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerContent({ className, children, ...props }: React.ComponentProps<typeof DrawerPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTitle({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerDescription({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/components/ui/spinner.d.ts

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): import("react/jsx-runtime").JSX.Element;
+export { Spinner };

package/dist/core/client.d.ts

@@ -0,0 +1,38 @@
+import type { TypeOfClientPlugin, TypeOfClientResponse, ICreateClientOptions, IRequestOptions } from "./types";
+import { type IResolvedClientConfiguration } from "./types";
+/**
+ * Core SDK client.
+ *
+ * Design goals:
+ * - Multi-tenant first: every request can include a tenantId
+ * - Extensible: plugins can add namespaces without modifying core
+ * - Minimal deps: uses fetch + AbortController only
+ * - Stable DX: options objects everywhere, predictable error model
+ */
+export declare class SDKClient {
+    readonly config: Readonly<IResolvedClientConfiguration>;
+    private readonly http;
+    private readonly plugins;
+    private readonly tenantOverride?;
+    constructor(options: ICreateClientOptions | IResolvedClientConfiguration, plugins?: ReadonlyArray<TypeOfClientPlugin<Record<string, unknown>>>, tenantOverride?: string);
+    /**
+     * Create a new client instance scoped to a tenant.
+     * This is the preferred DX over passing tenantId on every call.
+     */
+    withTenant(tenantId: string): this;
+    /**
+     * Extend the client with a plugin (recommended: return a namespace object).
+     *
+     * Example plugin style:
+     *   const withHealth = () => (client) => ({
+     *     health: { ping: () => client.requestOrThrow('/health') }
+     *   })
+     */
+    extend<Ext extends Record<string, unknown>>(plugin: TypeOfClientPlugin<Ext>): this & Ext;
+    /** Supabase-ish shape: returns { data, error } instead of throwing by default. */
+    request<T = unknown, TBody = unknown>(path: string, options?: IRequestOptions<TBody>): Promise<TypeOfClientResponse<T>>;
+    /** Convenience for folks who want exception-style flow. */
+    requestOrThrow<T = unknown, TBody = unknown>(path: string, options?: IRequestOptions<TBody>): Promise<T>;
+    get<T = unknown>(path: string, options?: Omit<IRequestOptions, "method" | "body">): Promise<TypeOfClientResponse<T>>;
+    post<T = unknown, TBody = unknown>(path: string, body: TBody, options?: Omit<IRequestOptions<TBody>, "method" | "body">): Promise<TypeOfClientResponse<T>>;
+}

package/dist/core/errors/errors.d.ts

@@ -1,5 +1,4 @@
-export type TypeOfErrorCode = "CONFIG_ERROR" | "NETWORK_ERROR" | "TIMEOUT" | "ABORTED" | "HTTP_ERROR" | "PARSE_ERROR" | "UNKNOWN_ERROR";
-export type TypeOfErrorMeta = Readonly<Record<string, unknown>>;
+import type { TypeOfErrorCode, TypeOfErrorMeta } from "../types";
 /**
  * Base error type for the SDK.
  * - Always has a stable `code`
@@ -44,6 +43,3 @@ export declare class AarthikHTTPError extends AarthikError {
         meta?: TypeOfErrorMeta;
     });
 }
-/** Best-effort check for AbortError thrown by fetch implementations. */
-export declare function isAarthikAbortedError(error: unknown): boolean;
-export declare function toAarthikError(error: unknown): AarthikError;

package/dist/core/types/client.d.ts

@@ -0,0 +1,161 @@
+import type { TypeOfAwaitable, TypeOfHeaderRecord, TypeOfQueryParameters } from "./utilities";
+import type { AarthikError } from "../errors";
+export type TypeOfHTTPRequestMethod = "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE" | "PATCH";
+export type TypeOfFetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface ILogger {
+    debug?: (...args: unknown[]) => void;
+    information?: (...args: unknown[]) => void;
+    warning?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+}
+export interface ITenantOptions {
+    /**
+     * Default tenant for this client instance.
+     * You can override per call via request options, or create a new scoped client via withTenant().
+     */
+    defaultTenantID?: string;
+    /**
+     * Header name used to send the tenant.
+     * Default: "x-tenant-id"
+     */
+    headerName?: string;
+    /**
+     * Optional resolver for the tenantId (useful if you store it in app state).
+     * Called for every request.
+     */
+    resolveTenantID?: () => TypeOfAwaitable<string | null | undefined>;
+}
+export interface IAuthOptions {
+    /**
+     * Static token (OK for browser *public tokens*).
+     * Prefer getToken() if tokens rotate.
+     */
+    token?: string;
+    /**
+     * Called on each request to fetch the current token (e.g. from storage).
+     */
+    getToken?: () => TypeOfAwaitable<string | null | undefined>;
+    /**
+     * Header name for auth token. Default: "authorization"
+     */
+    headerName?: string;
+    /**
+     * Scheme for the auth header. Default: "Bearer"
+     * Use empty string ("") to send the token raw.
+     */
+    scheme?: string;
+}
+export interface IRetryPolicy {
+    /** Total attempts INCLUDING the first attempt. Default: 1 (no retries). */
+    maxAttempts: number;
+    /** Base delay for exponential backoff. Default: 200 */
+    baseDelayMs: number;
+    /** Max delay cap for exponential backoff. Default: 2000 */
+    maxDelayMs: number;
+    /** Add jitter to reduce thundering herds. Default: true */
+    jitter: boolean;
+    /** Retry only these methods by default. */
+    retryableMethods: ReadonlyArray<TypeOfHTTPRequestMethod>;
+    /** Retry on these HTTP status codes. */
+    retryableStatusCodes: ReadonlyArray<number>;
+    /** Retry on network-ish failures thrown by fetch. Default: true */
+    retryOnNetworkError: boolean;
+}
+export interface ICorrelationOptions {
+    /** Header name. Default: "x-correlation-id" */
+    headerName?: string;
+    /** Custom generator (default uses crypto.randomUUID() when available). */
+    generate?: () => string;
+}
+export interface IIdempotencyOptions {
+    /** Header name. Default: "idempotency-key" */
+    headerName?: string;
+}
+export interface IHooks {
+    beforeRequest?: (ctx: IBeforeRequestContext) => TypeOfAwaitable<void>;
+    afterResponse?: (ctx: IAfterResponseContext) => TypeOfAwaitable<void>;
+}
+export interface IBaseHooksContext {
+    method: TypeOfHTTPRequestMethod;
+    URL: string;
+    path: string;
+    attempt: number;
+    correlationID: string;
+    tenantID?: string;
+    headers: Headers;
+}
+export interface IBeforeRequestContext extends IBaseHooksContext {
+    request?: Request;
+}
+export interface IAfterResponseContext extends IBaseHooksContext {
+    response?: Response;
+    durationMs: number;
+}
+export interface ICreateClientOptions {
+    baseURL: string;
+    /**
+     * Optional default headers (or a function to produce them per request).
+     */
+    headers?: TypeOfHeaderRecord | ((ctx: Omit<IBeforeRequestContext, "headers">) => TypeOfAwaitable<TypeOfHeaderRecord | undefined>);
+    /**
+     * Supply a custom fetch (SSR, tests, custom instrumentation).
+     * Default: globalThis.fetch
+     */
+    fetch?: TypeOfFetchLike;
+    /**
+     * Default request timeout.
+     * Default: 30_000
+     */
+    timeoutMs?: number;
+    /**
+     * Retry config. Default is conservative (no retries unless you set it).
+     */
+    retry?: Partial<IRetryPolicy>;
+    tenant?: ITenantOptions;
+    auth?: IAuthOptions;
+    correlation?: ICorrelationOptions;
+    idempotency?: IIdempotencyOptions;
+    /**
+     * Adds a custom "client info" header for server-side analytics / debugging.
+     * Browsers generally forbid setting "User-Agent", so use this instead.
+     */
+    clientInformation?: {
+        headerName?: string;
+        value?: string;
+    };
+    hooks?: IHooks;
+    logger?: ILogger;
+}
+export interface IRequestOptions<TypeOfBody = unknown> {
+    method?: TypeOfHTTPRequestMethod;
+    headers?: TypeOfHeaderRecord | ((ctx: Omit<IBeforeRequestContext, "headers">) => TypeOfAwaitable<TypeOfHeaderRecord | undefined>);
+    query?: TypeOfQueryParameters;
+    body?: TypeOfBody;
+    /** Per-request timeout override. */
+    timeoutMs?: number;
+    /** Per-request tenant override. */
+    tenantID?: string;
+    /** Optional idempotency key (recommended for mutating requests). */
+    idempotencyKey?: string;
+    /** Provide an AbortSignal (React Query, cancellation, etc.). */
+    signal?: AbortSignal;
+    /**
+     * If provided, overrides automatic body parsing.
+     * Useful for streaming endpoints, custom formats, etc.
+     */
+    parse?: <T = unknown>(res: Response) => Promise<T>;
+}
+export type TypeOfClientResponse<Type> = {
+    data: Type;
+    error: null;
+    status: number;
+    correlationID: string;
+    headers: Headers;
+} | {
+    data: null;
+    error: AarthikError;
+    status?: number;
+    correlationID: string;
+    headers?: Headers;
+};
+export type TypeOfClientPlugin<Extension extends object> = (client: unknown) => Extension;

package/dist/core/types/errors.d.ts

@@ -0,0 +1,2 @@
+export type TypeOfErrorCode = "CONFIG_ERROR" | "NETWORK_ERROR" | "TIMEOUT" | "ABORTED" | "HTTP_ERROR" | "PARSE_ERROR" | "UNKNOWN_ERROR";
+export type TypeOfErrorMeta = Readonly<Record<string, unknown>>;

package/dist/core/types/http.d.ts

@@ -0,0 +1,18 @@
+import type { IAuthOptions, ICorrelationOptions, ICreateClientOptions, IIdempotencyOptions, ILogger, IRetryPolicy, ITenantOptions } from ".";
+export interface IResolvedClientConfiguration {
+    baseURL: string;
+    fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    timeoutMs: number;
+    retry: IRetryPolicy;
+    tenant: Required<Pick<ITenantOptions, "headerName">> & ITenantOptions;
+    auth: Required<Pick<IAuthOptions, "headerName" | "scheme">> & IAuthOptions;
+    correlation: Required<Pick<ICorrelationOptions, "headerName" | "generate">> & ICorrelationOptions;
+    idempotency: Required<Pick<IIdempotencyOptions, "headerName">> & IIdempotencyOptions;
+    clientInformation: {
+        headerName: string;
+        value?: string;
+    };
+    headers?: ICreateClientOptions["headers"];
+    hooks?: ICreateClientOptions["hooks"];
+    logger?: ILogger;
+}

package/dist/core/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./utilities";
+export * from "./errors";
+export * from "./client";
+export * from "./http";

package/dist/core/types/utilities.d.ts

@@ -0,0 +1,5 @@
+export type TypeOfAwaitable<Type> = Type | Promise<Type>;
+export type TypeOfHeaderValue = string | number | boolean | null | undefined;
+export type TypeOfHeaderRecord = Record<string, TypeOfHeaderValue>;
+export type TypeOfQueryValue = string | number | boolean | null | undefined;
+export type TypeOfQueryParameters = Record<string, TypeOfQueryValue | TypeOfQueryValue[]>;

package/dist/core/utilities/errors.d.ts

@@ -0,0 +1,4 @@
+import { AarthikError } from "../errors";
+/** Best-effort check for AbortError thrown by fetch implementations. */
+export declare function isAarthikAbortedError(error: unknown): boolean;
+export declare function toAarthikError(error: unknown): AarthikError;

package/dist/core/utilities/http.d.ts

@@ -0,0 +1,6 @@
+import type { TypeOfClientResponse, ICreateClientOptions, IRequestOptions, IResolvedClientConfiguration } from "../types";
+export declare function resolveClientConfiguration(input: ICreateClientOptions): IResolvedClientConfiguration;
+export declare function createHTTPClient(configuration: IResolvedClientConfiguration): {
+    request: <Type = unknown, TypeOfBody = unknown>(path: string, options?: IRequestOptions<TypeOfBody>, clientTenantOverride?: string) => Promise<TypeOfClientResponse<Type>>;
+    requestOrThrow: <Type = unknown, TypeOfBody = unknown>(path: string, options?: IRequestOptions<TypeOfBody>, clientTenantOverride?: string) => Promise<Type>;
+};

package/dist/core/utilities/index.d.ts

@@ -1 +1,3 @@
-export {};
+export * from "./errors";
+export * from "./utilities";
+export * from "./http";

package/dist/core/utilities/utilities.d.ts

@@ -1,16 +1,12 @@
-export type TypeOfAwaitable<Type> = Type | Promise<Type>;
-export type TypeOfHeaderValue = string | number | boolean | null | undefined;
-export type TypeofHeaderRecord = Record<string, TypeOfHeaderValue>;
+import type { TypeOfHeaderRecord, TypeOfQueryParameters } from "../types";
 export declare function assert(condition: unknown, message: string): asserts condition;
 /**
  * Minimal random ID with strong preference for crypto.randomUUID().
  * Works in modern browsers and Node 18+.
  */
 export declare function randomID(): string;
-export declare function normalizeHeaderRecord(input?: TypeofHeaderRecord): TypeofHeaderRecord;
-export declare function mergeHeaders(...sources: Array<HeadersInit | TypeofHeaderRecord | undefined>): Headers;
-export type TypeOfQueryValue = string | number | boolean | null | undefined;
-export type TypeOfQueryParameters = Record<string, TypeOfQueryValue | TypeOfQueryValue[]>;
+export declare function normalizeHeaderRecord(input?: TypeOfHeaderRecord): TypeOfHeaderRecord;
+export declare function mergeHeaders(...sources: Array<HeadersInit | TypeOfHeaderRecord | undefined>): Headers;
 export declare function toSearchParameters(query?: TypeOfQueryParameters): URLSearchParams;
 export declare function joinURL(baseURL: string, path: string): string;
 /**

package/dist/hooks/index.d.cts

@@ -1 +1,2 @@
-export {};
+import { useIsMobile } from "./use-mobile";
+export { useIsMobile };

package/dist/hooks/index.d.ts

@@ -1 +1,2 @@
-export {};
+import { useIsMobile } from "./use-mobile";
+export { useIsMobile };

package/dist/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;