simplesvelte 2.2.11 → 2.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "simplesvelte",
-	"version": "2.2.11",
+	"version": "2.2.13",
 	"scripts": {
 		"dev": "bun vite dev",
 		"build": "bun vite build && bun run prepack",

package/dist/ag-grid.d.ts

@@ -1,551 +0,0 @@
-/**
- * AG Grid Server-Side Row Model (SSRM) - Server-Side Implementation API
- *
- * This module provides a clean, strongly-typed interface for implementing
- * AG Grid's Server-Side Row Model on the backend with any data source.
- *
- * @example Server-Side Usage (SvelteKit Remote Function)
- * ```typescript
- * import { createAGGridQuery, agGridRequestSchema } from './ag-grid'
- * import { query } from '$app/server'
- *
- * export const getUsersPaginated = query(agGridRequestSchema, async (request) => {
- *   return await createAGGridQuery({
- *     async fetch(params) {
- *       // Your data fetching logic
- *       const users = await DB.user.findMany({
- *         where: params.where,
- *         orderBy: params.orderBy,
- *         skip: params.skip,
- *         take: params.take,
- *       })
- *       return users
- *     },
- *     async count(params) {
- *       return await DB.user.count({ where: params.where })
- *     }
- *   })(request)
- * })
- * ```
- */
-import type { IServerSideDatasource } from 'ag-grid-enterprise';
-import { z } from 'zod';
-/**
- * Column configuration from AG Grid
- */
-export interface AGGridColumn {
-    id: string;
-    displayName: string;
-    field?: string;
-    aggFunc?: string;
-}
-/**
- * Sort configuration
- */
-export interface AGGridSort {
-    colId: string;
-    sort: 'asc' | 'desc';
-}
-/**
- * Filter model from AG Grid
- * This is a simplified type - actual filters can be more complex
- */
-export type AGGridFilterModel = Record<string, unknown>;
-/**
- * Request parameters sent from AG Grid to the data fetcher
- */
-export interface AGGridRequest {
-    /** Starting row index (0-based) */
-    startRow?: number;
-    /** Ending row index (exclusive) */
-    endRow?: number;
-    /** Current filter configuration */
-    filterModel?: AGGridFilterModel;
-    /** Current sort configuration */
-    sortModel: AGGridSort[];
-    /** Columns being used for row grouping */
-    rowGroupCols: AGGridColumn[];
-    /** Current group keys for drill-down */
-    groupKeys: string[];
-    /** Columns with aggregation functions */
-    valueCols: AGGridColumn[];
-    /** Columns being pivoted */
-    pivotCols: AGGridColumn[];
-    /** Whether pivot mode is enabled */
-    pivotMode: boolean;
-}
-/**
- * Response from the data fetcher back to AG Grid
- */
-export interface AGGridResponse<TData = unknown> {
-    /** The row data for this request */
-    rows: TData[];
-    /**
-     * Total number of rows available (for pagination)
-     * - For leaf-level data: total count matching the filter
-     * - For group rows: number of groups at this level
-     * - If undefined, AG Grid assumes all rows have been loaded
-     */
-    lastRow?: number;
-    /** Optional metadata for group levels */
-    groupLevelInfo?: unknown;
-    /** Pivot result fields (for pivot mode) */
-    pivotResultFields?: string[];
-}
-/**
- * Data fetcher function type
- * Implement this to connect AG Grid to your backend
- */
-export type AGGridDataFetcher<TData = unknown> = (request: AGGridRequest) => Promise<AGGridResponse<TData>>;
-/**
- * Options for datasource creation
- */
-export interface AGGridDatasourceOptions {
-    /** Called when a request fails */
-    onError?: (error: unknown) => void;
-    /** Called before each request is made */
-    onBeforeRequest?: (request: AGGridRequest) => void;
-    /** Called after each successful response */
-    onAfterResponse?: (response: AGGridResponse) => void;
-    /** Enable debug logging */
-    debug?: boolean;
-}
-/**
- * Zod schema for AG Grid column configuration
- */
-export declare const agGridColumnSchema: z.ZodObject<{
-    id: z.ZodString;
-    displayName: z.ZodString;
-    field: z.ZodOptional<z.ZodString>;
-    aggFunc: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    displayName: string;
-    field?: string | undefined;
-    aggFunc?: string | undefined;
-}, {
-    id: string;
-    displayName: string;
-    field?: string | undefined;
-    aggFunc?: string | undefined;
-}>;
-/**
- * Zod schema for AG Grid sort configuration
- */
-export declare const agGridSortSchema: z.ZodObject<{
-    colId: z.ZodString;
-    sort: z.ZodEnum<["asc", "desc"]>;
-}, "strip", z.ZodTypeAny, {
-    sort: "asc" | "desc";
-    colId: string;
-}, {
-    sort: "asc" | "desc";
-    colId: string;
-}>;
-/**
- * Zod schema for AG Grid request
- * Use this in your remote function schema: query(agGridRequestSchema, async (request) => ...)
- */
-export declare const agGridRequestSchema: z.ZodObject<{
-    startRow: z.ZodOptional<z.ZodNumber>;
-    endRow: z.ZodOptional<z.ZodNumber>;
-    filterModel: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    sortModel: z.ZodArray<z.ZodObject<{
-        colId: z.ZodString;
-        sort: z.ZodEnum<["asc", "desc"]>;
-    }, "strip", z.ZodTypeAny, {
-        sort: "asc" | "desc";
-        colId: string;
-    }, {
-        sort: "asc" | "desc";
-        colId: string;
-    }>, "many">;
-    rowGroupCols: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-        field: z.ZodOptional<z.ZodString>;
-        aggFunc: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }>, "many">;
-    groupKeys: z.ZodArray<z.ZodString, "many">;
-    valueCols: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-        field: z.ZodOptional<z.ZodString>;
-        aggFunc: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }>, "many">;
-    pivotCols: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-        field: z.ZodOptional<z.ZodString>;
-        aggFunc: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }, {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }>, "many">;
-    pivotMode: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    pivotMode: boolean;
-    sortModel: {
-        sort: "asc" | "desc";
-        colId: string;
-    }[];
-    rowGroupCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    groupKeys: string[];
-    valueCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    pivotCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    startRow?: number | undefined;
-    endRow?: number | undefined;
-    filterModel?: Record<string, unknown> | undefined;
-}, {
-    pivotMode: boolean;
-    sortModel: {
-        sort: "asc" | "desc";
-        colId: string;
-    }[];
-    rowGroupCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    groupKeys: string[];
-    valueCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    pivotCols: {
-        id: string;
-        displayName: string;
-        field?: string | undefined;
-        aggFunc?: string | undefined;
-    }[];
-    startRow?: number | undefined;
-    endRow?: number | undefined;
-    filterModel?: Record<string, unknown> | undefined;
-}>;
-/**
- * Parsed query parameters from AG Grid request
- * This is what you'll use to query your database
- */
-export interface AGGridQueryParams<TWhereInput = Record<string, unknown>> {
-    /** WHERE clause for filtering */
-    where: TWhereInput;
-    /** ORDER BY clause for sorting (use Record<string, unknown>[] for Prisma compatibility) */
-    orderBy: Record<string, unknown>[];
-    /** Number of rows to skip (for pagination) */
-    skip: number;
-    /** Number of rows to take (for pagination) */
-    take: number;
-    /** Current grouping level (for row grouping) */
-    groupLevel: number;
-    /** Group keys for drill-down */
-    groupKeys: string[];
-    /** Column being grouped at current level */
-    groupColumn?: AGGridColumn;
-    /** Whether this is a group request or leaf data request */
-    isGroupRequest: boolean;
-}
-/**
- * Configuration for a computed/virtual field
- *
- * Use this ONLY for truly computed/calculated values, not for simple nested relations.
- *
- * For nested relations (e.g., showing 'location.name'), use dot notation directly in
- * your column definitions instead:
- *   { field: 'location.name', headerName: 'Location' }
- *
- * computedFields are for complex calculations like:
- * - Week ending dates calculated from another date field
- * - Full names concatenated from firstName + lastName
- * - Custom aggregations or transformations
- */
-export interface ComputedField<TRecord = unknown, TWhereInput = Record<string, unknown>> {
-    /** Column ID in AG Grid */
-    columnId: string;
-    /**
-     * Database field to use for sorting/filtering (for simple nested fields)
-     * Only use this with computedFields if you need a custom field name.
-     * Otherwise, use dot notation directly in column definitions.
-     */
-    dbField?: string;
-    /**
-     * Custom function to compute the value for display
-     * Required for complex calculations.
-     */
-    valueGetter?: (record: TRecord) => unknown;
-    /**
-     * Custom filter handler
-     * Required for complex computed fields that need custom filter logic.
-     */
-    filterHandler?: (filterValue: unknown, where: TWhereInput) => void;
-    /**
-     * Custom group filter handler
-     * Required for complex computed fields that need custom grouping logic.
-     */
-    groupHandler?: (groupKey: string, where: TWhereInput) => void;
-}
-/**
- * Configuration for AG Grid query builder
- */
-export interface AGGridQueryConfig<TRecord = unknown, TWhereInput = Record<string, unknown>> {
-    /** Function to fetch data rows */
-    fetch: (params: AGGridQueryParams<TWhereInput>) => Promise<TRecord[]>;
-    /** Function to count total rows */
-    count: (params: AGGridQueryParams<TWhereInput>) => Promise<number>;
-    /** Optional: Computed/virtual fields configuration */
-    computedFields?: ComputedField<TRecord, TWhereInput>[];
-    /** Optional: Default sort when no sort specified */
-    defaultSort?: Record<string, 'asc' | 'desc'>;
-    /** Optional: Transform where clause before query */
-    transformWhere?: (where: TWhereInput, request: AGGridRequest) => TWhereInput;
-}
-/**
- * Creates an AG Grid query handler for server-side data fetching
- *
- * This is the main server-side API. Use this in your remote functions or API endpoints
- * to handle AG Grid requests with any database/data source.
- *
- * @param config - Configuration for data fetching and field mappings
- * @returns Function that processes AG Grid requests and returns responses
- *
- * @example Basic Prisma Usage
- * ```typescript
- * export const getUsersPaginated = query(agGridRequestSchema, async (request) => {
- *   return await createAGGridQuery({
- *     async fetch(params) {
- *       return await DB.user.findMany({
- *         where: params.where,
- *         orderBy: params.orderBy,
- *         skip: params.skip,
- *         take: params.take,
- *       })
- *     },
- *     async count(params) {
- *       return await DB.user.count({ where: params.where })
- *     },
- *     defaultSort: { createdAt: 'desc' }
- *   })(request)
- * })
- * ```
- *
- * @example With Nested Relations (Use Dot Notation)
- * ```typescript
- * // Server-side - just include the relation
- * return await createAGGridQuery({
- *   async fetch(params) {
- *     return await DB.intervention.findMany({
- *       where: params.where,
- *       orderBy: params.orderBy,
- *       skip: params.skip,
- *       take: params.take,
- *       include: { location: true }
- *     })
- *   },
- *   async count(params) {
- *     return await DB.intervention.count({ where: params.where })
- *   }
- * })(request)
- *
- * // Client-side - use dot notation in column definitions
- * const columnDefs = [
- *   { field: 'id' },
- *   { field: 'location.name', headerName: 'Location', filter: 'agTextColumnFilter' },
- * ]
- * // That's it! Auto-handles display, filtering, sorting, and grouping
- * ```
- *
- * @example With Computed Fields (Complex Calculations)
- * ```typescript
- * return await createAGGridQuery({
- *   async fetch(params) {
- *     return await DB.intervention.findMany({
- *       where: params.where,
- *       orderBy: params.orderBy,
- *       skip: params.skip,
- *       take: params.take,
- *     })
- *   },
- *   async count(params) {
- *     return await DB.intervention.count({ where: params.where })
- *   },
- *   computedFields: [
- *     {
- *       // Complex computed field - provide custom handlers
- *       columnId: 'weekEnding',
- *       valueGetter: (record) => calculateWeekEnding(record.date),
- *       filterHandler: (filterValue, where) => {
- *         // Custom filter logic for week ending
- *       }
- *     }
- *   ]
- * })(request)
- * ```
- */
-export declare function createAGGridQuery<TRecord = unknown, TWhereInput = Record<string, unknown>>(config: AGGridQueryConfig<TRecord, TWhereInput>): (request: AGGridRequest) => Promise<AGGridResponse<TRecord>>;
-/**
- * Creates an AG Grid server-side datasource from a data fetcher function
- *
- * This is the main entry point for implementing SSRM. Simply provide a function
- * that fetches data based on AG Grid's request, and this handles all the
- * AG Grid datasource protocol.
- *
- * @param fetcher - Function that fetches data based on AG Grid's request
- * @param options - Optional configuration for error handling and logging
- * @returns IServerSideDatasource compatible with AG Grid
- *
- * @example
- * ```typescript
- * const datasource = createAGGridDatasource(async (request) => {
- *   const { startRow, endRow, filterModel, sortModel } = request
- *
- *   // Your data fetching logic here
- *   const data = await fetchFromAPI({
- *     offset: startRow,
- *     limit: endRow - startRow,
- *     filters: filterModel,
- *     sorts: sortModel
- *   })
- *
- *   return {
- *     rows: data.items,
- *     lastRow: data.total
- *   }
- * })
- * ```
- */
-export declare function createAGGridDatasource<TData = unknown>(fetcher: AGGridDataFetcher<TData>, options?: AGGridDatasourceOptions): IServerSideDatasource<TData>;
-/**
- * Checks if the current request is for leaf-level data (not groups)
- *
- * @param request - AG Grid request
- * @returns true if requesting leaf data, false if requesting groups
- */
-export declare function isLeafDataRequest(request: AGGridRequest): boolean;
-/**
- * Gets the current grouping level (0-based)
- *
- * @param request - AG Grid request
- * @returns Current group level, or -1 if not grouping
- */
-export declare function getCurrentGroupLevel(request: AGGridRequest): number;
-/**
- * Gets the column being grouped at the current level
- *
- * @param request - AG Grid request
- * @returns Column configuration for current group level, or undefined
- */
-export declare function getCurrentGroupColumn(request: AGGridRequest): AGGridColumn | undefined;
-/**
- * Default column definition for SSRM grids
- */
-export declare const defaultSSRMColDef: import('ag-grid-community').ColDef;
-/**
- * Default grid options for SSRM
- */
-export declare const defaultSSRMGridOptions: Partial<import('ag-grid-community').GridOptions>;
-/**
- * Predefined filter configurations for common column types
- */
-export declare const filterConfigs: {
-    /** Text column with text filter */
-    readonly text: {
-        readonly filter: "agTextColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-            readonly suppressAndOrCondition: true;
-        };
-    };
-    /** Number column with number filter */
-    readonly number: {
-        readonly filter: "agNumberColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-            readonly suppressAndOrCondition: true;
-        };
-    };
-    /** Date column with date filter */
-    readonly date: {
-        readonly filter: "agDateColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-            readonly suppressAndOrCondition: true;
-        };
-    };
-    /** Date range filter (for start dates) */
-    readonly startDate: {
-        readonly filter: "agDateColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-            readonly suppressAndOrCondition: true;
-            readonly filterOptions: readonly ["greaterThan", "inRange"];
-        };
-    };
-    /** Date range filter (for end dates) */
-    readonly endDate: {
-        readonly filter: "agDateColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-            readonly suppressAndOrCondition: true;
-            readonly filterOptions: readonly ["lessThan", "inRange"];
-        };
-    };
-    /** Set filter (for categories) */
-    readonly set: {
-        readonly filter: "agSetColumnFilter";
-        readonly filterParams: {
-            readonly buttons: readonly ["clear"];
-        };
-    };
-    /** Boolean filter (Yes/No) */
-    readonly boolean: {
-        readonly filter: "agSetColumnFilter";
-        readonly filterParams: {
-            readonly values: readonly ["Yes", "No"];
-            readonly buttons: readonly ["clear"];
-        };
-    };
-};