glasswork 0.2.4 → 0.3.1

package/dist/hooks/index.js

@@ -1,55 +0,0 @@
-/**
- * Service hooks system for wrapping service method calls with before/after/error hooks.
- *
- * This module provides a flexible hook system that can be used for:
- * - Authorization (using CASL)
- * - Audit logging
- * - Metrics and tracing
- * - Error handling
- * - Retry logic
- * - Timeouts
- * - Response transformation
- *
- * Hooks are transparent - they wrap service methods without modifying the service
- * implementation, keeping business logic clean and framework-agnostic.
- *
- * @module hooks
- *
- * @example Basic Usage
- * ```typescript
- * import { authorizationHook, defineServiceMetadata } from 'glasswork';
- *
- * // Define metadata for service methods
- * export const authServiceMetadata = defineServiceMetadata({
- *   deleteSession: {
- *     authorize: {
- *       action: 'delete',
- *       subject: 'Session'
- *     }
- *   }
- * });
- *
- * // Configure hooks globally in bootstrap
- * bootstrap({
- *   serviceHooks: [authorizationHook],
- *   serviceMetadata: {
- *     authService: authServiceMetadata
- *   }
- * });
- *
- * // In routes, service calls are automatically wrapped
- * export const authRoutes = createRoutes((router, { authService }) => {
- *   router.delete('/session', ...route({
- *     handler: async ({ context }) => {
- *       // This automatically checks authorization before executing!
- *       await authService.deleteSession(token);
- *     }
- *   }));
- * });
- * ```
- */
-// Built-in hooks
-export { authorizationHook, defineAuthorize, } from './authorization-hook.js';
-// Hook system
-export { defineServiceMetadata, withServiceHooks, withServiceHooksMany, } from './service-hooks.js';
-//# sourceMappingURL=index.js.map

package/dist/hooks/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,iBAAiB;AACjB,OAAO,EAEL,iBAAiB,EACjB,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAEjC,cAAc;AACd,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/hooks/service-hooks.d.ts

@@ -1,82 +0,0 @@
-import type { Context } from 'hono';
-import type { ServiceHooksConfig, ServiceMethodMetadata } from './types.js';
-/**
- * Wraps a service with hooks that run before/after/on-error for method calls.
- * This creates a transparent proxy that intercepts method calls and runs hooks
- * while preserving all service functionality.
- *
- * **Note:** Hooks only run for method calls, not property access.
- *
- * @param service - The service instance to wrap
- * @param config - Hook configuration
- * @param honoContext - The current Hono request context
- * @returns Proxied service with hooks
- *
- * @example
- * ```typescript
- * const authHook: ServiceHook = {
- *   before: async (context) => {
- *     if (context.metadata?.authorize) {
- *       authorize(context.honoContext, ...);
- *     }
- *   }
- * };
- *
- * const wrappedService = withServiceHooks(authService, {
- *   hooks: [authHook],
- *   metadata: {
- *     deleteSession: {
- *       authorize: { action: 'delete', subject: 'Session' }
- *     }
- *   }
- * }, honoContext);
- *
- * // Hooks automatically run when calling methods
- * await wrappedService.deleteSession(token);
- * ```
- */
-export declare function withServiceHooks<T extends object>(service: T, config: ServiceHooksConfig, honoContext: Context): T;
-/**
- * Wraps multiple services with the same hooks configuration.
- * Useful when you want to apply the same hooks to all services in a container.
- *
- * @param services - Object containing service instances
- * @param config - Hook configuration (can be a function for per-service config)
- * @param honoContext - The current Hono request context
- * @returns Object with all services wrapped with hooks
- *
- * @example
- * ```typescript
- * const wrappedServices = withServiceHooksMany(
- *   { authService, userService },
- *   (serviceName) => ({
- *     hooks: [authHook, auditHook],
- *     metadata: serviceMetadataRegistry[serviceName],
- *     serviceName,
- *   }),
- *   honoContext
- * );
- * ```
- */
-export declare function withServiceHooksMany<T extends Record<string, object>>(services: T, config: ServiceHooksConfig | ((serviceName: string, service: unknown) => ServiceHooksConfig), honoContext: Context): T;
-/**
- * Helper to define service method metadata with better type inference.
- * This is just an identity function that helps TypeScript understand the structure.
- *
- * @param metadata - Service method metadata mapping
- * @returns The same metadata (identity function)
- *
- * @example
- * ```typescript
- * export const authServiceMetadata = defineServiceMetadata({
- *   deleteSession: {
- *     authorize: { action: 'delete', subject: 'Session' }
- *   },
- *   findById: {
- *     authorize: { action: 'read', subject: 'User' }
- *   }
- * });
- * ```
- */
-export declare function defineServiceMetadata(metadata: Record<string, ServiceMethodMetadata>): Record<string, ServiceMethodMetadata>;
-//# sourceMappingURL=service-hooks.d.ts.map

package/dist/hooks/service-hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-hooks.d.ts","sourceRoot":"","sources":["../../src/hooks/service-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAGV,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAkDpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,kBAAkB,EAC1B,WAAW,EAAE,OAAO,GACnB,CAAC,CAqCH;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACnE,QAAQ,EAAE,CAAC,EACX,MAAM,EAAE,kBAAkB,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,kBAAkB,CAAC,EAC5F,WAAW,EAAE,OAAO,GACnB,CAAC,CAcH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC9C,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAEvC"}

package/dist/hooks/service-hooks.js

@@ -1,158 +0,0 @@
-/**
- * Execute a method with hooks (before/after/error).
- * Extracted as a helper to reduce complexity.
- */
-async function executeWithHooks(hookContext, hooks, 
-// biome-ignore lint/suspicious/noExplicitAny: Function type requires any
-originalMethod, target, args) {
-    try {
-        // Run all before hooks
-        for (const hook of hooks) {
-            if (hook.before) {
-                await hook.before(hookContext, args);
-            }
-        }
-        // Execute original method
-        let result = await originalMethod.apply(target, args);
-        // Run all after hooks (in order)
-        for (const hook of hooks) {
-            if (hook.after) {
-                const hookResult = await hook.after(hookContext, args, result);
-                // If hook returns a value, use it as the new result
-                if (hookResult !== undefined) {
-                    result = hookResult;
-                }
-            }
-        }
-        return result;
-    }
-    catch (error) {
-        // Run all error hooks
-        for (const hook of hooks) {
-            if (hook.onError) {
-                await hook.onError(hookContext, args, error);
-            }
-        }
-        // Re-throw the error after hooks
-        throw error;
-    }
-}
-/**
- * Wraps a service with hooks that run before/after/on-error for method calls.
- * This creates a transparent proxy that intercepts method calls and runs hooks
- * while preserving all service functionality.
- *
- * **Note:** Hooks only run for method calls, not property access.
- *
- * @param service - The service instance to wrap
- * @param config - Hook configuration
- * @param honoContext - The current Hono request context
- * @returns Proxied service with hooks
- *
- * @example
- * ```typescript
- * const authHook: ServiceHook = {
- *   before: async (context) => {
- *     if (context.metadata?.authorize) {
- *       authorize(context.honoContext, ...);
- *     }
- *   }
- * };
- *
- * const wrappedService = withServiceHooks(authService, {
- *   hooks: [authHook],
- *   metadata: {
- *     deleteSession: {
- *       authorize: { action: 'delete', subject: 'Session' }
- *     }
- *   }
- * }, honoContext);
- *
- * // Hooks automatically run when calling methods
- * await wrappedService.deleteSession(token);
- * ```
- */
-export function withServiceHooks(service, config, honoContext) {
-    const { hooks, metadata = {}, serviceName } = config;
-    // Try to determine service name
-    const inferredServiceName = serviceName || service.constructor?.name || 'UnknownService';
-    return new Proxy(service, {
-        get(target, prop) {
-            // Only intercept string properties (method names)
-            if (typeof prop !== 'string') {
-                return Reflect.get(target, prop);
-            }
-            const originalValue = Reflect.get(target, prop);
-            // If it's not a function, return as-is
-            if (typeof originalValue !== 'function') {
-                return originalValue;
-            }
-            // Get metadata for this method
-            const methodMetadata = metadata[prop];
-            // Return wrapped function with hooks
-            return async function (...args) {
-                const hookContext = {
-                    honoContext,
-                    serviceName: inferredServiceName,
-                    methodName: prop,
-                    metadata: methodMetadata,
-                };
-                // biome-ignore lint/suspicious/noExplicitAny: originalValue is guaranteed to be a function by the check above
-                return executeWithHooks(hookContext, hooks, originalValue, target, args);
-            };
-        },
-    });
-}
-/**
- * Wraps multiple services with the same hooks configuration.
- * Useful when you want to apply the same hooks to all services in a container.
- *
- * @param services - Object containing service instances
- * @param config - Hook configuration (can be a function for per-service config)
- * @param honoContext - The current Hono request context
- * @returns Object with all services wrapped with hooks
- *
- * @example
- * ```typescript
- * const wrappedServices = withServiceHooksMany(
- *   { authService, userService },
- *   (serviceName) => ({
- *     hooks: [authHook, auditHook],
- *     metadata: serviceMetadataRegistry[serviceName],
- *     serviceName,
- *   }),
- *   honoContext
- * );
- * ```
- */
-export function withServiceHooksMany(services, config, honoContext) {
-    const result = {};
-    for (const [serviceName, service] of Object.entries(services)) {
-        const serviceConfig = typeof config === 'function' ? config(serviceName, service) : config;
-        result[serviceName] = withServiceHooks(service, { ...serviceConfig, serviceName }, honoContext);
-    }
-    return result;
-}
-/**
- * Helper to define service method metadata with better type inference.
- * This is just an identity function that helps TypeScript understand the structure.
- *
- * @param metadata - Service method metadata mapping
- * @returns The same metadata (identity function)
- *
- * @example
- * ```typescript
- * export const authServiceMetadata = defineServiceMetadata({
- *   deleteSession: {
- *     authorize: { action: 'delete', subject: 'Session' }
- *   },
- *   findById: {
- *     authorize: { action: 'read', subject: 'User' }
- *   }
- * });
- * ```
- */
-export function defineServiceMetadata(metadata) {
-    return metadata;
-}
-//# sourceMappingURL=service-hooks.js.map

package/dist/hooks/service-hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"service-hooks.js","sourceRoot":"","sources":["../../src/hooks/service-hooks.ts"],"names":[],"mappings":"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"}

package/dist/hooks/types.d.ts

@@ -1,151 +0,0 @@
-import type { Context } from 'hono';
-/**
- * Context passed to service hooks containing the current Hono request context
- * and any additional metadata about the service call.
- */
-export interface ServiceHookContext {
-    /**
-     * The Hono request context, providing access to request data,
-     * response helpers, and context variables (like user, ability, etc.)
-     */
-    honoContext: Context;
-    /**
-     * The name of the service being called (e.g., 'authService', 'userService')
-     */
-    serviceName: string;
-    /**
-     * The name of the method being called (e.g., 'deleteSession', 'findById')
-     */
-    methodName: string;
-    /**
-     * Optional metadata associated with this service method.
-     * Can be used to pass configuration like authorization rules, audit info, etc.
-     */
-    metadata?: unknown;
-}
-/**
- * Hook function that runs before a service method is executed.
- * Can be used for authorization, validation, logging, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments being passed to the service method
- * @throws Error to prevent the service method from executing
- *
- * @example
- * ```typescript
- * const authorizationHook: ServiceBeforeHook = async (context, args) => {
- *   const { honoContext, metadata } = context;
- *   if (metadata?.authorize) {
- *     authorize(honoContext, metadata.authorize.action, metadata.authorize.subject);
- *   }
- * };
- * ```
- */
-export type ServiceBeforeHook = (context: ServiceHookContext, args: unknown[]) => Promise<void> | void;
-/**
- * Hook function that runs after a service method successfully executes.
- * Can be used for audit logging, metrics, response transformation, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments that were passed to the service method
- * @param result - The result returned by the service method
- * @returns Optionally return a transformed result
- *
- * @example
- * ```typescript
- * const auditHook: ServiceAfterHook = async (context, args, result) => {
- *   await auditLog.create({
- *     service: context.serviceName,
- *     method: context.methodName,
- *     args,
- *     timestamp: new Date(),
- *   });
- * };
- * ```
- */
-export type ServiceAfterHook = (context: ServiceHookContext, args: unknown[], result: unknown) => Promise<unknown | undefined> | unknown | undefined;
-/**
- * Hook function that runs when a service method throws an error.
- * Can be used for error logging, error transformation, retries, etc.
- *
- * @param context - Hook context with Hono context and service info
- * @param args - Arguments that were passed to the service method
- * @param error - The error that was thrown
- * @throws Error to propagate or throw a different error
- *
- * @example
- * ```typescript
- * const errorLoggingHook: ServiceErrorHook = async (context, args, error) => {
- *   logger.error('Service error', {
- *     service: context.serviceName,
- *     method: context.methodName,
- *     error,
- *   });
- *   // Re-throw to propagate
- *   throw error;
- * };
- * ```
- */
-export type ServiceErrorHook = (context: ServiceHookContext, args: unknown[], error: unknown) => undefined | never | Promise<undefined | never>;
-/**
- * A service hook that can define before, after, and error handlers.
- */
-export interface ServiceHook {
-    /**
-     * Optional hook that runs before the service method executes.
-     */
-    before?: ServiceBeforeHook;
-    /**
-     * Optional hook that runs after the service method successfully executes.
-     */
-    after?: ServiceAfterHook;
-    /**
-     * Optional hook that runs when the service method throws an error.
-     */
-    onError?: ServiceErrorHook;
-}
-/**
- * Metadata that can be attached to service methods to configure hook behavior.
- */
-export type ServiceMethodMetadata = Record<string, unknown>;
-/**
- * Configuration for applying hooks to a service.
- */
-export interface ServiceHooksConfig {
-    /**
-     * Array of hooks to apply to the service.
-     * Hooks run in the order they're defined.
-     */
-    hooks: ServiceHook[];
-    /**
-     * Optional metadata for service methods.
-     * Keys are method names, values are metadata objects.
-     *
-     * @example
-     * ```typescript
-     * {
-     *   deleteSession: {
-     *     authorize: { action: 'delete', subject: 'Session' }
-     *   },
-     *   findById: {
-     *     authorize: { action: 'read', subject: 'User' },
-     *     cache: { ttl: 300 }
-     *   }
-     * }
-     * ```
-     */
-    metadata?: Record<string, ServiceMethodMetadata>;
-    /**
-     * Optional service name for better debugging.
-     * If not provided, will try to infer from the service constructor name.
-     */
-    serviceName?: string;
-}
-/**
- * Services registry that maps service names to their wrapped instances.
- * This is used internally by the route context to provide hooked services.
- */
-export type ServicesRegistry<T = unknown> = {
-    [K in keyof T]: T[K];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/hooks/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/hooks/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,KACZ,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,EACf,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,OAAO,GAAG,SAAS,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE,OAAO,EAAE,EACf,KAAK,EAAE,OAAO,KACX,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAEzB;;OAEG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,KAAK,EAAE,WAAW,EAAE,CAAC;IAErB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IAEjD;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,GAAG,OAAO,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAC"}

package/dist/utils/pagination.d.ts

@@ -1,48 +0,0 @@
-import type { Context } from 'hono';
-/**
- * Pagination input parameters
- */
-export interface PaginationInput {
-    page: number;
-    limit: number;
-}
-/**
- * Paginated output structure
- */
-export interface PaginatedOutput<T> {
-    data: T[];
-    total: number;
-    page: number;
-    limit: number;
-}
-/**
- * Execute a paginated query and set response headers.
- *
- * This helper extracts pagination parameters from the query string,
- * executes the provided function, and sets the appropriate response headers.
- *
- * @template T - The type of items in the result
- * @param c - Hono context
- * @param fn - Function that executes the paginated query
- * @returns Array of items (headers are set as side effect)
- *
- * @example
- * ```typescript
- * router.get('/users', route({
- *   paginate: true,
- *   handler: async ({ context }) => {
- *     return await paginate(context, (p) => userService.getUsers(p));
- *   }
- * }));
- * ```
- */
-export declare function paginate<T>(c: Context, fn: (p: PaginationInput) => Promise<PaginatedOutput<T>>): Promise<T[]>;
-/**
- * Extract pagination parameters from Hono context.
- *
- * @param c - Hono context
- * @param defaultLimit - Default limit if not provided (default: 100)
- * @returns Pagination input with page and limit
- */
-export declare function paginationInput(c: Context, defaultLimit?: number): PaginationInput;
-//# sourceMappingURL=pagination.d.ts.map

package/dist/utils/pagination.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/utils/pagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,CAAC,EAAE,OAAO,EACV,EAAE,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,GACtD,OAAO,CAAC,CAAC,EAAE,CAAC,CASd;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,SAAM,GAAG,eAAe,CAI/E"}

package/dist/utils/pagination.js

@@ -1,42 +0,0 @@
-/**
- * Execute a paginated query and set response headers.
- *
- * This helper extracts pagination parameters from the query string,
- * executes the provided function, and sets the appropriate response headers.
- *
- * @template T - The type of items in the result
- * @param c - Hono context
- * @param fn - Function that executes the paginated query
- * @returns Array of items (headers are set as side effect)
- *
- * @example
- * ```typescript
- * router.get('/users', route({
- *   paginate: true,
- *   handler: async ({ context }) => {
- *     return await paginate(context, (p) => userService.getUsers(p));
- *   }
- * }));
- * ```
- */
-export async function paginate(c, fn) {
-    const pagination = paginationInput(c);
-    const result = await fn(pagination);
-    c.header('X-Total-Count', result.total.toString());
-    c.header('X-Page', result.page.toString());
-    c.header('X-Limit', result.limit.toString());
-    return result.data;
-}
-/**
- * Extract pagination parameters from Hono context.
- *
- * @param c - Hono context
- * @param defaultLimit - Default limit if not provided (default: 100)
- * @returns Pagination input with page and limit
- */
-export function paginationInput(c, defaultLimit = 100) {
-    const page = Number.parseInt(c.req.query('page') ?? '1', 10);
-    const limit = Number.parseInt(c.req.query('limit') ?? defaultLimit.toString(), 10);
-    return { page, limit };
-}
-//# sourceMappingURL=pagination.js.map

package/dist/utils/pagination.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../src/utils/pagination.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,CAAU,EACV,EAAuD;IAEvD,MAAM,UAAU,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,UAAU,CAAC,CAAC;IAEpC,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACnD,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC3C,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAE7C,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,CAAU,EAAE,YAAY,GAAG,GAAG;IAC5D,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;IAC7D,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,YAAY,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IACnF,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACzB,CAAC"}