@benjosivo/table-query 1.0.3 → 1.2.0

package/dist/react/useDataTable.js

@@ -1,5 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions = [10, 25, 50, 100, 250, 500, 1000], defaultRowsPerPage = 100, fetchFilterConfig, }) {
+import { sanitizeFormattingRules } from './formatting.js';
+import { getRowId, selectionKey } from './utils.js';
+export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions = [10, 25, 50, 100, 250, 500, 1000], defaultRowsPerPage = 100, fetchFilterConfig, selectedIds: controlledSelectedIds, onSelectionChange, }) {
     const [items, setItems] = useState([]);
     const [count, setCount] = useState(0);
     const [fieldsType, setFieldsType] = useState([]);
@@ -12,8 +14,17 @@ export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions =
     const [filters, setFilters] = useState({});
     const [filterConfig, setFilterConfig] = useState(null);
     const [cleRecupFiltre, setCleRecupFiltre] = useState();
+    const [serverFormattingRules, setServerFormattingRules] = useState([]);
     // Guards against a slow, stale request overwriting a newer one.
     const requestId = useRef(0);
+    // Selection is uncontrolled unless the parent passes `selectedIds`.
+    const [internalSelectedIds, setInternalSelectedIds] = useState([]);
+    const isSelectionControlled = controlledSelectedIds !== undefined;
+    const selectedIds = isSelectionControlled ? controlledSelectedIds : internalSelectedIds;
+    const selectedKeys = useMemo(() => new Set(selectedIds.map(selectionKey)), [selectedIds]);
+    /** Every row loaded since the last selection reset, so a row selected on a page we left
+     * can still be handed back to the parent in full. */
+    const knownRows = useRef(new Map());
     const sorting = useMemo(() => (sortColumn ? `\`${sortColumn}\` ${sortDirection}` : ''), [sortColumn, sortDirection]);
     const totalPages = useMemo(() => Math.max(1, Math.ceil(count / perPage)), [count, perPage]);
     const load = useCallback(async (targetPage) => {
@@ -35,7 +46,13 @@ export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions =
                 setCount(0);
                 return;
             }
-            setItems(result.items || []);
+            const rows = result.items || [];
+            for (const row of rows) {
+                const rowId = getRowId(row);
+                if (rowId !== undefined)
+                    knownRows.current.set(selectionKey(rowId), row);
+            }
+            setItems(rows);
             setCount(result.count ?? 0);
             setFieldsType(result.fieldsType || []);
             setParamFilter(result.paramFilter || []);
@@ -44,6 +61,8 @@ export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions =
                 setFilterConfig(result.filtre);
             if (result.cleRecupFiltre)
                 setCleRecupFiltre(result.cleRecupFiltre);
+            if (result.formattingRules)
+                setServerFormattingRules(sanitizeFormattingRules(result.formattingRules));
         }
         finally {
             if (id === requestId.current)
@@ -96,6 +115,63 @@ export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions =
     /** Replace the whole filter object at once — handy for a custom search UI that
      * doesn't reason "per column" and just wants to hand over its own `filtre` payload. */
     const replaceFilters = useCallback((next) => setFilters(next), []);
+    // ==================== SELECTION ====================
+    const rowsOf = useCallback((ids) => {
+        const rows = [];
+        for (const id of ids) {
+            const row = knownRows.current.get(selectionKey(id));
+            if (row)
+                rows.push(row);
+        }
+        return rows;
+    }, []);
+    const selectedRows = useMemo(() => rowsOf(selectedIds), [selectedIds, items, rowsOf]);
+    const applySelection = useCallback((nextIds) => {
+        if (!isSelectionControlled)
+            setInternalSelectedIds(nextIds);
+        onSelectionChange?.(nextIds, rowsOf(nextIds));
+    }, [isSelectionControlled, onSelectionChange, rowsOf]);
+    const isRowSelected = useCallback((row) => selectedKeys.has(selectionKey(getRowId(row))), [selectedKeys]);
+    const setRowSelected = useCallback((row, selected) => {
+        const id = getRowId(row);
+        if (id === undefined)
+            return;
+        const key = selectionKey(id);
+        knownRows.current.set(key, row);
+        if (selected === selectedKeys.has(key))
+            return;
+        applySelection(selected ? [...selectedIds, id] : selectedIds.filter((v) => selectionKey(v) !== key));
+    }, [selectedIds, selectedKeys, applySelection]);
+    const toggleRowSelection = useCallback((row) => setRowSelected(row, !isRowSelected(row)), [setRowSelected, isRowSelected]);
+    /** Select/deselect every row of the current page; rows selected on other pages are left alone. */
+    const setAllRowsSelected = useCallback((selected) => {
+        const pageIds = [];
+        for (const row of items) {
+            const id = getRowId(row);
+            if (id === undefined)
+                continue;
+            knownRows.current.set(selectionKey(id), row);
+            pageIds.push(id);
+        }
+        const pageKeys = new Set(pageIds.map(selectionKey));
+        const others = selectedIds.filter((id) => !pageKeys.has(selectionKey(id)));
+        applySelection(selected ? [...others, ...pageIds] : others);
+    }, [items, selectedIds, applySelection]);
+    const clearSelection = useCallback(() => {
+        if (selectedIds.length > 0)
+            applySelection([]);
+    }, [selectedIds, applySelection]);
+    // The selection spans pages, but a new sort/filter means a different dataset: start over.
+    const firstDatasetRender = useRef(true);
+    useEffect(() => {
+        if (firstDatasetRender.current) {
+            firstDatasetRender.current = false;
+            return;
+        }
+        knownRows.current.clear();
+        clearSelection();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sorting, filters]);
     const changePerPage = useCallback((n) => setPerPage(n), []);
     return {
         items,
@@ -111,6 +187,14 @@ export function useDataTable({ fetchData, advancedFilters, rowsPerPageOptions =
         sortDirection,
         filters,
         filterConfig,
+        serverFormattingRules,
+        selectedIds,
+        selectedRows,
+        isRowSelected,
+        toggleRowSelection,
+        setRowSelected,
+        setAllRowsSelected,
+        clearSelection,
         toggleSort,
         setColumnFilter,
         replaceFilters,

package/dist/react/useFormattingRules.d.ts

@@ -0,0 +1,34 @@
+import type { FormattingRule } from './types.js';
+export interface UseFormattingRulesOptions {
+    /** Rules set by the app (lowest priority). */
+    propsRules?: FormattingRule[];
+    /** Rules sent by the API. */
+    serverRules?: FormattingRule[];
+    /** When set, the user's rules persist in localStorage under this key. */
+    storageKey?: string;
+    /** Rehydrate the user's rules from your own backend — wins over localStorage. */
+    initialUserRules?: FormattingRule[];
+    /** Called on every change to the user's rules. */
+    onChange?: (rules: FormattingRule[]) => void;
+}
+export interface UseFormattingRulesResult {
+    /** Merged and ordered props -> server -> user, ready for <Table formattingRules>. */
+    rules: FormattingRule[];
+    /** The user-editable layer. */
+    userRules: FormattingRule[];
+    /** The props + server layers, read-only in the editor. */
+    inherited: FormattingRule[];
+    /** Ids of inherited rules the user has switched off. */
+    disabledIds: string[];
+    addRule: (rule: FormattingRule) => void;
+    updateRule: (id: string, patch: Partial<FormattingRule>) => void;
+    removeRule: (id: string) => void;
+    moveRule: (id: string, delta: 1 | -1) => void;
+    setRuleDisabled: (id: string, disabled: boolean) => void;
+    resetUserRules: () => void;
+}
+/**
+ * Owns the three formatting layers and their persistence. Lives in a hook rather than in
+ * `DataTable` so that a host composing `useDataTable` + `Table` by hand can reuse it.
+ */
+export declare function useFormattingRules({ propsRules, serverRules, storageKey, initialUserRules, onChange, }: UseFormattingRulesOptions): UseFormattingRulesResult;

package/dist/react/useFormattingRules.js

@@ -0,0 +1,121 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { newRuleId, sanitizeFormattingRules } from './formatting.js';
+/** Namespaced so a storage key can't collide with the host app's own localStorage entries. */
+const STORAGE_PREFIX = 'tableQuery:formatting:';
+const STORAGE_VERSION = 1;
+function serialize(rules, disabled) {
+    return JSON.stringify({ v: STORAGE_VERSION, rules, disabled });
+}
+/** Inherited rules need a stable id even when the source didn't give them one. */
+function withFallbackIds(rules, source) {
+    if (!rules || rules.length === 0)
+        return [];
+    return rules.map((r, i) => (r.id ? r : { ...r, id: `${source}:${i}` }));
+}
+/**
+ * Owns the three formatting layers and their persistence. Lives in a hook rather than in
+ * `DataTable` so that a host composing `useDataTable` + `Table` by hand can reuse it.
+ */
+export function useFormattingRules({ propsRules, serverRules, storageKey, initialUserRules, onChange, }) {
+    const [userRules, setUserRules] = useState(() => (initialUserRules ? sanitizeFormattingRules(initialUserRules) : []));
+    const [disabledIds, setDisabledIds] = useState([]);
+    const fullKey = storageKey ? `${STORAGE_PREFIX}${storageKey}` : undefined;
+    // Hydration is STATE, not a ref: both effects run in the same commit on mount, so a ref
+    // flipped by the read effect would already read true in the write effect below — which
+    // would rewrite [] over the rules just loaded and fire a spurious onChange([]).
+    const [hydrated, setHydrated] = useState(false);
+    // What is already in storage, so an unchanged value never triggers a write or an onChange.
+    const lastWritten = useRef(null);
+    // Read post-mount, never in the useState initializer: with SSR the server renders no user
+    // rules, so reading during the first render would cause a hydration mismatch on the styles.
+    useEffect(() => {
+        // Baseline = the state as it stands before hydration, so the first write-effect pass is
+        // a no-op. Without it, mounting with nothing stored would fire onChange([]) and wipe the
+        // rules of a host that persists them server-side.
+        lastWritten.current = serialize(userRules, disabledIds);
+        if (initialUserRules || !fullKey || typeof window === 'undefined') {
+            setHydrated(true);
+            return;
+        }
+        try {
+            const raw = window.localStorage.getItem(fullKey);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                // An unknown version is ignored rather than migrated; the next write replaces it.
+                if (parsed && parsed.v === STORAGE_VERSION) {
+                    const rules = sanitizeFormattingRules(parsed.rules);
+                    const disabled = Array.isArray(parsed.disabled) ? parsed.disabled.filter((x) => typeof x === 'string') : [];
+                    setUserRules(rules);
+                    setDisabledIds(disabled);
+                    lastWritten.current = serialize(rules, disabled);
+                }
+            }
+        }
+        catch {
+            // SSR, Safari private mode, blocked storage, corrupted JSON — all non-fatal.
+        }
+        setHydrated(true);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [fullKey]);
+    useEffect(() => {
+        if (!hydrated)
+            return;
+        const serialized = serialize(userRules, disabledIds);
+        // Nothing actually changed (the mount pass, or a re-render): don't write, don't notify.
+        if (lastWritten.current === serialized)
+            return;
+        lastWritten.current = serialized;
+        if (fullKey && typeof window !== 'undefined') {
+            try {
+                window.localStorage.setItem(fullKey, serialized);
+            }
+            catch {
+                // Quota exceeded or storage blocked: the rules still work for this session.
+            }
+        }
+        onChange?.(userRules);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [userRules, disabledIds, fullKey, hydrated]);
+    const inherited = useMemo(() => [...withFallbackIds(propsRules, 'props'), ...withFallbackIds(serverRules, 'server')], [propsRules, serverRules]);
+    /**
+     * Precedence: props -> server -> user. Evaluation order IS precedence order, so a later
+     * rule wins per CSS property and an earlier `stopIfTrue` can block a later layer.
+     */
+    const rules = useMemo(() => {
+        const disabled = new Set(disabledIds);
+        return [...inherited, ...userRules].filter((r) => r.enabled !== false && !(r.id && disabled.has(r.id)));
+    }, [inherited, userRules, disabledIds]);
+    const addRule = useCallback((rule) => {
+        setUserRules((prev) => [...prev, { ...rule, id: rule.id || newRuleId() }]);
+    }, []);
+    const updateRule = useCallback((id, patch) => {
+        setUserRules((prev) => prev.map((r) => (r.id === id ? { ...r, ...patch } : r)));
+    }, []);
+    const removeRule = useCallback((id) => {
+        setUserRules((prev) => prev.filter((r) => r.id !== id));
+    }, []);
+    const moveRule = useCallback((id, delta) => {
+        setUserRules((prev) => {
+            const i = prev.findIndex((r) => r.id === id);
+            const j = i + delta;
+            if (i < 0 || j < 0 || j >= prev.length)
+                return prev;
+            const next = [...prev];
+            [next[i], next[j]] = [next[j], next[i]];
+            return next;
+        });
+    }, []);
+    const setRuleDisabled = useCallback((id, disabled) => {
+        setDisabledIds((prev) => {
+            const has = prev.includes(id);
+            if (disabled === has)
+                return prev;
+            return disabled ? [...prev, id] : prev.filter((x) => x !== id);
+        });
+    }, []);
+    const resetUserRules = useCallback(() => {
+        setUserRules([]);
+        setDisabledIds([]);
+    }, []);
+    return { rules, userRules, inherited, disabledIds, addRule, updateRule, removeRule, moveRule, setRuleDisabled, resetUserRules };
+}

package/dist/react/utils.d.ts

@@ -4,3 +4,15 @@ export declare function looksLikeFile(str: string): boolean;
 /** Returns HTML with <span class="..."> wrapping each JSON token, for use with dangerouslySetInnerHTML. */
 export declare function syntaxHighlightJSON(json: string): string;
 export declare function truncatedJSON(value: unknown, maxLen?: number): string;
+/** Id of a row: the value of its first column — same rule as onRowClick. */
+export declare function getRowId(row: Record<string, any> | undefined): any;
+/** Ids come from the data (numbers, strings, ...) and can be compared to values given by the parent, so normalize them. */
+export declare function selectionKey(id: any): string;
+/**
+ * Column names of a table: the keys of the first row, falling back to the filter
+ * definitions when there is no data. Shared by `Table` and the formatting editor so the
+ * two can't drift apart.
+ */
+export declare function columnNamesOf(items: Record<string, any>[], paramFilter?: {
+    nom: string;
+}[]): string[];

package/dist/react/utils.js

@@ -38,3 +38,24 @@ export function truncatedJSON(value, maxLen = 200) {
     const truncated = str.length > maxLen ? `${str.slice(0, maxLen)}...` : str;
     return syntaxHighlightJSON(truncated);
 }
+/** Id of a row: the value of its first column — same rule as onRowClick. */
+export function getRowId(row) {
+    if (!row)
+        return undefined;
+    const key = Object.keys(row)[0];
+    return key === undefined ? undefined : row[key];
+}
+/** Ids come from the data (numbers, strings, ...) and can be compared to values given by the parent, so normalize them. */
+export function selectionKey(id) {
+    return String(id);
+}
+/**
+ * Column names of a table: the keys of the first row, falling back to the filter
+ * definitions when there is no data. Shared by `Table` and the formatting editor so the
+ * two can't drift apart.
+ */
+export function columnNamesOf(items, paramFilter) {
+    if (items[0])
+        return Object.keys(items[0]);
+    return paramFilter && paramFilter.length > 0 ? paramFilter.map((el) => el.nom) : [];
+}

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import type { CacheDeps, ParamFilterType, ReqTableQueryOptions, TableQueryDeps } from './types.js';
-export type { CacheDeps, ParamFilterType, ReqTableQueryOptions, TableQueryDeps } from './types.js';
+export type { CacheDeps, FormattingRuleInput, ParamFilterType, ReqTableQueryOptions, TableQueryDeps } from './types.js';
 /**
  * Creates the table-query module (router + query helpers) bound to this project's own
  * date formatting / route-wrapping / cache implementations. Nothing here is hardcoded to
@@ -11,8 +11,8 @@ export type { CacheDeps, ParamFilterType, ReqTableQueryOptions, TableQueryDeps }
 export declare function createTableQueryModule(deps: TableQueryDeps): {
     router: import("express-serve-static-core").Router;
     reqTableQuery: (opt: ReqTableQueryOptions) => Promise<{
-        error: string;
-        status: number;
+        error: string | undefined;
+        status: number | undefined;
         empty?: undefined;
         data?: undefined;
     } | {

package/dist/server/index.js

@@ -52,7 +52,7 @@ export function createTableQueryModule(deps) {
         sendFiltres();
     }
     async function reqTableQuery(opt) {
-        const { query, req, paramFilter, sort, argsQuery, keepCache = 5 * 60 * 1000 } = opt;
+        const { query, req, paramFilter, sort, argsQuery, formattingRules, keepCache = 5 * 60 * 1000 } = opt;
         if (!req.body && !req.query) {
             return { error: `req.query or req.body is missing`, status: 400 };
         }
@@ -69,11 +69,27 @@ export function createTableQueryModule(deps) {
         // ── Paginated items ────────────────────────────────────────────────
         const itemsSql = `${query} ${whereClause} ORDER BY ${sorting} LIMIT ${limit < 0 ? 0 : limit} OFFSET ${offset < 0 ? 0 : offset}`;
         let { payload, status, error, empty } = await getDataFromQuery(itemsSql, argsQuery, cache ? keepCache : 0, cache);
+        // getDataFromQuery returns { status, error } with no payload when the query fails.
+        if (!payload)
+            return { error, status };
         payload.paramFilter = paramFilter
             ? paramFilter.map((param, i) => {
                 return { nom: payload.fieldsType[i].fieldName, type: param };
             })
             : [];
+        // Forwarded untouched — formatting is presentation, it never reaches the SQL.
+        // Resolved by column NAME against the very same source `paramFilter` is zipped against,
+        // so the two can't drift. Sent on every request (a few hundred bytes), not gated behind
+        // setFilter, so the client needs no extra round-trip.
+        if (formattingRules?.length) {
+            const names = new Set((payload.fieldsType ?? []).map((f) => f.fieldName));
+            const kept = formattingRules.filter((r) => r && typeof r.column === 'string' && names.has(r.column));
+            const dropped = formattingRules.length - kept.length;
+            // A bad column name is a presentation mistake: warn, don't take the table down.
+            if (dropped)
+                console.warn(`[table-query] ${dropped} règle(s) de mise en forme ignorée(s) : colonne inconnue.`);
+            payload.formattingRules = kept;
+        }
         if (empty)
             return { empty, data: payload };
         if (error && status)
@@ -124,12 +140,17 @@ export function createTableQueryModule(deps) {
             if (tableValues.length === 0)
                 return { empty: true, payload: { items: tableValues, count: 0, fieldsType: reqRows.fieldsType } };
             Object.keys(tableValues[0]).forEach((col, i) => {
-                if (col === 'Documents')
+                if (col.toLowerCase().trim() === 'documents')
                     reqRows.fieldsType[i].fieldType = 'FILE';
             });
             payload = { items: tableValues, count: reqRows.rows[0]?.TotalCount ?? 0, fieldsType: reqRows.fieldsType };
             if (cache && keepCache) {
-                await cache.setSQLCache(titleSQLCacheQuery, { title: titleSQLCacheQuery, data: payload, expiration: Date.now() + keepCache });
+                await cache.setSQLCache(titleSQLCacheQuery, {
+                    title: titleSQLCacheQuery,
+                    data: payload,
+                    expiration: Date.now() + keepCache,
+                    tables: reqRows.tables,
+                });
             }
         }
         return { payload };

package/dist/server/types.d.ts

@@ -1,5 +1,24 @@
 import type { Request, Response } from 'express';
 export type ParamFilterType = 'HIDE' | 'SLIDER' | 'DATE' | 'DATETIME' | 'UNGROUP_MULTISELECT' | 'MULTISELECT' | null | 'JSON' | 'FILE';
+/**
+ * Same shape as the React-side `FormattingRule`, but with no dependency on @types/react:
+ * the server only ever forwards these rules, it never evaluates them, and a server-only
+ * consumer must not be forced to install React's types to compile.
+ */
+export interface FormattingRuleInput {
+    id?: string;
+    label?: string;
+    /** Name of the tested column, matched against the query's own column names. */
+    column: string;
+    operator: string;
+    value?: unknown;
+    valueType?: 'auto' | 'string' | 'number' | 'date' | 'boolean';
+    target?: 'row' | 'cell' | string[];
+    style?: Record<string, string | number>;
+    className?: string;
+    stopIfTrue?: boolean;
+    enabled?: boolean;
+}
 export interface CacheDeps {
     getSQLCache: (key: string) => Promise<any>;
     setSQLCache: (key: string, value: any) => Promise<any>;
@@ -20,6 +39,9 @@ export interface ReqTableQueryOptions {
     argsQuery?: any[];
     /** How long (ms) a cached result stays valid. Only used when `useCache` resolves to true. */
     keepCache?: number;
+    /** Conditional formatting rules forwarded as-is to the client in `payload.formattingRules`.
+     *  Rules whose `column` matches no column of the query are dropped. */
+    formattingRules?: FormattingRuleInput[];
     /** Use the Redis cache for this call. Defaults to true if `deps.cache` was provided at
      * module creation, false otherwise. Pass `false` explicitly to always force a fresh query
      * even when the module has a cache configured (e.g. for a "live" screen). */

package/package.json

@@ -1,61 +1,61 @@
-{
-    "name": "@benjosivo/table-query",
-    "version": "1.0.3",
-    "description": "Table triable/filtrable/paginée : hook + composants React d'un côté (`/react`), logique SQL de pagination/tri/filtres côté serveur de l'autre (`/server`). Un projet peut n'utiliser qu'un des deux côtés.",
-    "keywords": [],
-    "homepage": "https://github.com/benjosivo/table-query#readme",
-    "bugs": {
-        "url": "https://github.com/benjosivo/table-query/issues"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/benjosivo/table-query.git"
-    },
-    "license": "ISC",
-    "author": "benjosivo",
-    "type": "module",
-    "exports": {
-        "./react": {
-            "types": "./dist/react/index.d.ts",
-            "default": "./dist/react/index.js"
-        },
-        "./server": {
-            "types": "./dist/server/index.d.ts",
-            "default": "./dist/server/index.js"
-        }
-    },
-    "main": "index.js",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "build": "tsc",
-        "prepublishOnly": "npm run build"
-    },
-    "dependencies": {
-        "@benjosivo/mysql": "^1.3.2",
-        "express": "^5.2.1"
-    },
-    "devDependencies": {
-        "@types/express": "^5.0.6",
-        "@types/react": "^18.0.0",
-        "typescript": "^5.4.0"
-    },
-    "peerDependencies": {
-        "react": "^18.0.0 || ^19.0.0"
-    },
-    "peerDependenciesMeta": {
-        "express": {
-            "optional": true
-        },
-        "react": {
-            "optional": true
-        },
-        "@benjosivo/mysql": {
-            "optional": true
-        }
-    },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org"
-    }
-}
+{
+    "name": "@benjosivo/table-query",
+    "version": "1.2.0",
+    "description": "Table triable/filtrable/paginée : hook + composants React d'un côté (`/react`), logique SQL de pagination/tri/filtres côté serveur de l'autre (`/server`). Un projet peut n'utiliser qu'un des deux côtés.",
+    "keywords": [],
+    "homepage": "https://github.com/benjosivo/table-query#readme",
+    "bugs": {
+        "url": "https://github.com/benjosivo/table-query/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/benjosivo/table-query.git"
+    },
+    "license": "ISC",
+    "author": "benjosivo",
+    "type": "module",
+    "exports": {
+        "./react": {
+            "types": "./dist/react/index.d.ts",
+            "default": "./dist/react/index.js"
+        },
+        "./server": {
+            "types": "./dist/server/index.d.ts",
+            "default": "./dist/server/index.js"
+        }
+    },
+    "main": "index.js",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "@benjosivo/mysql": "^1.3.2",
+        "express": "^5.2.1"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.6",
+        "@types/react": "^18.0.0",
+        "typescript": "^5.4.0"
+    },
+    "peerDependencies": {
+        "react": "^18.0.0 || ^19.0.0"
+    },
+    "peerDependenciesMeta": {
+        "express": {
+            "optional": true
+        },
+        "react": {
+            "optional": true
+        },
+        "@benjosivo/mysql": {
+            "optional": true
+        }
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org"
+    }
+}