@btst/stack 4.6.0 → 5.1.0

package/dist/shared/stack.29zv4pIu.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Server-safe resource declaration types and query-key/queryFn builder.
+ *
+ * A plugin declares its resources once (paths, query mappings, unwrapping,
+ * key discriminators) and gets:
+ *
+ * - `createResourceQueryKeys(client, resources, headers?)` — a query-key
+ *   factory usable from SSR loaders and `query-keys.ts` (no React), with the
+ *   same `_def` / `queryKey` shapes as `@lukemorales/query-key-factory`, so
+ *   existing SSG `prefetchForRoute` / `query-key-defs.ts` keys keep matching.
+ * - `createResource(...)` (see `./hooks`) — generated React Query hooks.
+ */
+/**
+ * Minimal better-call client shape the resource layer needs.
+ * Any `createApiClient<TRouter>()` result is assignable.
+ */
+type ResourceClient = (path: any, options?: any) => Promise<unknown>;
+/**
+ * Declaration for a single query on a resource.
+ *
+ * Query-key shape: `[resourceName, queryName, ...key(...args)]` where `key`
+ * defaults to the args themselves. Share discriminator functions with
+ * `api/query-key-defs.ts` to keep SSG prefetch keys in sync.
+ */
+interface ResourceQueryDef<TArgs extends readonly unknown[] = readonly any[], TData = unknown> {
+    /** better-call endpoint path, e.g. `"/posts"` or `"/content/:typeSlug"` */
+    path: string;
+    /** Maps hook args to the endpoint path params (for `:param` segments) */
+    params?: (...args: TArgs) => Record<string, string>;
+    /** Maps hook args to the HTTP query object */
+    query?: (...args: TArgs) => Record<string, unknown> | undefined;
+    /**
+     * Maps hook args to the queryKey discriminator cells appended after
+     * `[resourceName, queryName]`. Defaults to the args themselves.
+     */
+    key?: (...args: TArgs) => readonly unknown[];
+    /** Unwraps/selects data from the raw response data */
+    select?: (data: any, ...args: TArgs) => TData;
+    /**
+     * Offset-paginated infinite query. The queryFn receives `pageParam` and
+     * injects it into the HTTP query as `offsetParam`. `select` must return
+     * an array (one page of items).
+     */
+    infinite?: boolean;
+    /** HTTP query param carrying the page offset (default `"offset"`) */
+    offsetParam?: string;
+    /**
+     * Page size used to derive `getNextPageParam` for infinite queries
+     * (default 10). A function form derives it from the hook args.
+     */
+    pageSize?: number | ((...args: TArgs) => number);
+    /**
+     * Custom `getNextPageParam` for infinite queries whose pages are not
+     * plain item arrays (e.g. `{ items, total }` envelopes). Overrides the
+     * default page-size heuristic. Return `undefined` when there is no
+     * next page.
+     */
+    nextPageParam?: (lastPage: TData, allPages: TData[], ...args: TArgs) => unknown | undefined;
+    /** When true, skip fetching and resolve `null` (e.g. missing id) */
+    skip?: (...args: TArgs) => boolean;
+}
+/**
+ * Declaration for a single mutation on a resource.
+ */
+interface ResourceMutationDef<TVars = any, TResult = unknown> {
+    /** better-call endpoint path, e.g. `"@post/posts"` or `"@put/posts/:id"` */
+    path: string;
+    method: "POST" | "PUT" | "PATCH" | "DELETE";
+    /**
+     * Maps mutation variables to better-call call options.
+     * Defaults to `{ body: vars }`.
+     */
+    input?: (vars: TVars) => {
+        body?: unknown;
+        params?: Record<string, string>;
+        query?: Record<string, unknown>;
+    };
+    /** Unwraps the mutation result from the raw response data */
+    select?: (data: any) => TResult;
+    /**
+     * Query-key prefixes invalidated (awaited, in order) after success.
+     * `"posts"` invalidates the whole resource, `"posts.list"` one query.
+     */
+    invalidates?: readonly string[];
+    /**
+     * Which matching queries to refetch during invalidation. Defaults to
+     * React Query's `"active"`; use `"all"` when an inactive view must be
+     * refreshed before it remounts.
+     */
+    refetchType?: "active" | "inactive" | "all" | "none";
+    /**
+     * Seed a query cache entry from the mutation result (e.g. the detail
+     * entry for a created/updated record). `args` returns the key args for
+     * the target query, or `null` to skip seeding.
+     */
+    setData?: {
+        /** Target query name on the same resource (default `"detail"`) */
+        query?: string;
+        args: (result: TResult) => readonly unknown[] | null;
+        /**
+         * Optionally merge the mutation result with the existing cache value.
+         * Defaults to replacing the cached value with `result`.
+         */
+        updater?: (previous: unknown, result: TResult) => unknown;
+    };
+    /**
+     * Remove a query cache entry after success (e.g. the deleted record's
+     * detail query). `args` may derive the target key from both the result and
+     * the submitted variables, or return `null` to skip removal.
+     */
+    removeData?: {
+        /** Target query name on the same resource (default `"detail"`) */
+        query?: string;
+        args: (result: TResult, variables: TVars) => readonly unknown[] | null;
+    };
+    /**
+     * Whether to call the router `refresh` override after success (default
+     * `true`). Set `false` for mutations that must not reload server-rendered
+     * state — e.g. public submissions whose success UI lives in client state.
+     */
+    refresh?: boolean;
+}
+/** Declaration for one resource: its queries and (optionally) mutations. */
+interface ResourceDef {
+    queries: Record<string, ResourceQueryDef<any, any>>;
+    mutations?: Record<string, ResourceMutationDef<any, any>>;
+}
+/** A plugin's full resource declaration, keyed by resource name. */
+type ResourcesDeclaration = Record<string, ResourceDef>;
+/** Extracts the hook args tuple from a query declaration. */
+type ResourceQueryArgs<TDef> = TDef extends {
+    query: (...args: infer A) => any;
+} ? A : TDef extends {
+    params: (...args: infer A) => any;
+} ? A : TDef extends {
+    key: (...args: infer A) => any;
+} ? A : TDef extends {
+    select: (data: any, ...args: infer A) => any;
+} ? A : [];
+/** Extracts the (per-page, for infinite queries) data type from a query declaration. */
+type ResourceQueryData<TDef> = TDef extends {
+    select: (data: any, ...args: any[]) => infer D;
+} ? D : unknown;
+/** Extracts the variables type from a mutation declaration. */
+type ResourceMutationVars<TDef> = TDef extends {
+    input: (vars: infer V) => any;
+} ? V : unknown;
+/** Extracts the result type from a mutation declaration. */
+type ResourceMutationResult<TDef> = TDef extends {
+    select: (data: any) => infer R;
+} ? R : unknown;
+/**
+ * A query-key factory entry: call with args to get `{ queryKey, queryFn }`,
+ * read `_def` for the `[resourceName, queryName]` prefix.
+ */
+interface ResourceQueryEntry<TArgs extends readonly unknown[] = readonly any[], TData = unknown> {
+    (...args: TArgs): {
+        queryKey: readonly unknown[];
+        queryFn: (context?: {
+            pageParam?: unknown;
+        }) => Promise<TData>;
+    };
+    _def: readonly [string, string];
+}
+/** The query-key factory produced from a resources declaration. */
+type ResourceQueryKeys<TResources extends ResourcesDeclaration> = {
+    [R in keyof TResources]: {
+        [Q in keyof TResources[R]["queries"]]: ResourceQueryEntry<ResourceQueryArgs<TResources[R]["queries"][Q]>, ResourceQueryData<TResources[R]["queries"][Q]>>;
+    } & {
+        _def: readonly [R];
+    };
+};
+/** Resolves the effective page size for an infinite query declaration. */
+declare function resolvePageSize(def: ResourceQueryDef<any, any>, args: readonly unknown[]): number;
+/** Builds the full query key for a query declaration and args. */
+declare function buildQueryKey(resourceName: string, queryName: string, def: ResourceQueryDef<any, any>, args: readonly unknown[]): readonly unknown[];
+/**
+ * Executes the fetch → error-check → unwrap dance for a query declaration.
+ */
+declare function runResourceQuery(client: ResourceClient, def: ResourceQueryDef<any, any>, args: readonly unknown[], pageParam?: unknown, headers?: HeadersInit): Promise<unknown>;
+/**
+ * Executes a mutation declaration: fetch → error-check → unwrap.
+ *
+ * `headers` forwards already-resolved request headers to the resource client,
+ * matching the `headers` parameter on `createResourceQueryKeys`. Header
+ * resolution belongs to the caller's runtime.
+ */
+declare function runResourceMutation(client: ResourceClient, def: ResourceMutationDef<any, any>, vars: unknown, headers?: HeadersInit): Promise<unknown>;
+/**
+ * Builds a query-key factory from a resources declaration.
+ *
+ * Compatible with the shapes `@lukemorales/query-key-factory` produces:
+ * `store.posts.list(params)` → `{ queryKey: ["posts", "list", ...], queryFn }`,
+ * `store.posts.list._def` → `["posts", "list"]`, `store.posts._def` → `["posts"]`.
+ *
+ * Server-safe (no React) — usable from SSR loaders and `query-keys.ts`.
+ */
+declare function createResourceQueryKeys<const TResources extends ResourcesDeclaration>(client: ResourceClient, resources: TResources, headers?: HeadersInit): ResourceQueryKeys<TResources>;
+
+/**
+ * Shared error contract and React Query config for all data plugins.
+ *
+ * Every plugin used to copy-paste `isErrorResponse` / `toError` /
+ * `SHARED_QUERY_CONFIG` into its own `query-keys.ts` / hooks files. These now
+ * live in core and are exported once from `@btst/stack/plugins/client`.
+ */
+/**
+ * Standardized error shape thrown by resource queries and mutations.
+ *
+ * `errors` maps field names to validation message(s), preserving Zod
+ * field-level issues from better-call endpoint validation errors so form
+ * hooks can map them onto per-field error state.
+ */
+interface StackError extends Error {
+    statusCode?: number;
+    errors?: Record<string, string | string[]>;
+}
+/**
+ * Shared React Query configuration for all plugin queries.
+ * Prevents automatic refetching to avoid hydration mismatches in SSR.
+ */
+declare const SHARED_QUERY_CONFIG: {
+    readonly retry: false;
+    readonly refetchOnWindowFocus: false;
+    readonly refetchOnMount: false;
+    readonly refetchOnReconnect: false;
+    readonly staleTime: number;
+    readonly gcTime: number;
+};
+/**
+ * Type guard for better-call error responses.
+ * better-call client returns `Error$1<unknown> | Data<T>` — we check if
+ * `error` exists and is not null/undefined to determine it's an error response.
+ */
+declare function isErrorResponse(response: unknown): response is {
+    error: unknown;
+    data?: never;
+};
+/**
+ * Converts an unknown error (typically a better-call / better-fetch error
+ * response body) into a proper `StackError` with a meaningful message.
+ *
+ * Normalizes to `{ message, statusCode?, errors? }` where `errors` maps
+ * field names to validation messages (preserved from Zod issues in
+ * better-call endpoint validation error responses).
+ */
+declare function toError(error: unknown): StackError;
+
+export { SHARED_QUERY_CONFIG as S, buildQueryKey as l, createResourceQueryKeys as m, isErrorResponse as n, runResourceMutation as o, runResourceQuery as p, resolvePageSize as r, toError as t };
+export type { ResourceClient as R, ResourceDef as a, ResourceMutationDef as b, ResourceMutationResult as c, ResourceMutationVars as d, ResourceQueryArgs as e, ResourceQueryData as f, ResourceQueryDef as g, ResourceQueryEntry as h, ResourceQueryKeys as i, ResourcesDeclaration as j, StackError as k };

package/dist/shared/stack.611-G_G_.d.cts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getSteps as b, formSchemaToZod as f, getStepGroupMap as g, hasSteps as h, zodToFormSchema as z };
+export type { FormSchemaMetadata as F, FormStep as a };

package/dist/shared/stack.611-G_G_.d.mts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getSteps as b, formSchemaToZod as f, getStepGroupMap as g, hasSteps as h, zodToFormSchema as z };
+export type { FormSchemaMetadata as F, FormStep as a };

package/dist/shared/stack.611-G_G_.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getSteps as b, formSchemaToZod as f, getStepGroupMap as g, hasSteps as h, zodToFormSchema as z };
+export type { FormSchemaMetadata as F, FormStep as a };

package/dist/shared/stack.8By8qKPz.d.cts

@@ -0,0 +1,148 @@
+/**
+ * Options provided to storage adapters when initiating an upload.
+ */
+interface UploadOptions {
+    filename: string;
+    mimeType: string;
+    size: number;
+    folderId?: string;
+}
+/**
+ * Local storage adapter — backend receives and stores file bytes directly.
+ * Suitable for development and self-hosted deployments.
+ */
+interface DirectStorageAdapter {
+    readonly type: "local";
+    /**
+     * Store the file buffer and return the public URL.
+     */
+    upload(buffer: Buffer, options: UploadOptions): Promise<{
+        url: string;
+    }>;
+    /**
+     * Remove the stored file given its public URL.
+     */
+    delete(url: string): Promise<void>;
+}
+/**
+ * Token returned by the S3 adapter.
+ * The client performs a `PUT` to `payload.uploadUrl` with the file body,
+ * then saves `payload.publicUrl` as the asset URL.
+ */
+interface S3UploadToken {
+    type: "presigned-url";
+    payload: {
+        uploadUrl: string;
+        publicUrl: string;
+        key: string;
+        method: "PUT";
+        headers: Record<string, string>;
+    };
+}
+/**
+ * S3 storage adapter — server issues a short-lived presigned PUT URL;
+ * the browser uploads directly to S3 (or R2 / MinIO).
+ */
+interface S3StorageAdapter {
+    readonly type: "s3";
+    /**
+     * The public base URL prefix for all assets in this bucket
+     * (e.g. `"https://assets.example.com"`). Used by the plugin to
+     * automatically validate client-supplied URLs when no explicit
+     * `allowedUrlPrefixes` are configured.
+     */
+    readonly urlPrefix: string;
+    /**
+     * Generate a presigned PUT URL for direct client upload.
+     */
+    generateUploadToken(options: UploadOptions): Promise<S3UploadToken>;
+    /**
+     * Remove the stored object given its public URL.
+     */
+    delete(url: string): Promise<void>;
+}
+/**
+ * Options returned from onBeforeGenerateToken and passed to Vercel Blob's handleUpload.
+ */
+interface VercelBlobTokenOptions {
+    addRandomSuffix?: boolean;
+    allowedContentTypes?: string[];
+    maximumSizeInBytes?: number;
+    /** Server-normalized upload context bound into the signed client token. */
+    tokenPayload?: string;
+}
+/**
+ * Minimal blob metadata sent back by Vercel Blob's upload completion callback.
+ * Keep this intentionally small so BTST does not hard-depend on a specific SDK type.
+ */
+interface VercelBlobCallbackBlob {
+    url: string;
+    pathname: string;
+}
+interface VercelBlobGenerateClientTokenBody {
+    type: "blob.generate-client-token";
+    payload: {
+        pathname: string;
+        multipart: boolean;
+        clientPayload: string | null;
+        callbackUrl?: string;
+    };
+}
+interface VercelBlobUploadCompletedBody {
+    type: "blob.upload-completed";
+    payload: {
+        blob: VercelBlobCallbackBlob;
+        tokenPayload?: string | null;
+    };
+}
+type VercelBlobHandleUploadBody = VercelBlobGenerateClientTokenBody | VercelBlobUploadCompletedBody;
+/**
+ * Callbacks provided to the Vercel Blob adapter when handling a request.
+ */
+interface VercelBlobHandlerCallbacks {
+    /**
+     * Called before a client token is generated.
+     * Throw to reject the upload (auth gate).
+     * Return options to enforce allowedContentTypes and maximumSizeInBytes at the edge.
+     */
+    onBeforeGenerateToken?: (pathname: string, clientPayload: string | null) => Promise<VercelBlobTokenOptions | void> | VercelBlobTokenOptions | void;
+}
+/** Provider-verified upload context carried by a completion callback. */
+interface VerifiedVercelBlobCallback {
+    pathname: string;
+    mimeType: string;
+    size?: number;
+    folderId?: string;
+    tenantId?: string;
+}
+/**
+ * Vercel Blob storage adapter — uses the `@vercel/blob/client` `handleUpload`
+ * protocol. The same endpoint handles both token generation and upload
+ * completion notifications from Vercel's servers.
+ */
+interface VercelBlobStorageAdapter {
+    readonly type: "vercel-blob";
+    /**
+     * Hostname suffix that all Vercel Blob public URLs end with.
+     * Used by the plugin to automatically validate client-supplied URLs.
+     * Always `".public.blob.vercel-storage.com"`.
+     */
+    readonly urlHostnameSuffix: string;
+    /**
+     * Verify the provider signature and parse only server-issued token context.
+     * This runs before a completion callback is allowed onto a public auth path.
+     */
+    verifyCallback(request: Request, body: VercelBlobUploadCompletedBody): Promise<VerifiedVercelBlobCallback>;
+    /**
+     * Process a client-token request or Vercel Blob's upload-completion webhook.
+     * Returns a JSON-serialisable object that should be sent as the response body.
+     */
+    handleRequest(request: Request, body: VercelBlobHandleUploadBody, callbacks: VercelBlobHandlerCallbacks): Promise<unknown>;
+    /**
+     * Remove the stored blob given its public URL.
+     */
+    delete(url: string): Promise<void>;
+}
+type StorageAdapter = DirectStorageAdapter | S3StorageAdapter | VercelBlobStorageAdapter;
+
+export type { DirectStorageAdapter as D, S3StorageAdapter as S, UploadOptions as U, VercelBlobStorageAdapter as V, S3UploadToken as a, StorageAdapter as b, VercelBlobHandlerCallbacks as c };