npm - @rozenite/sqlite-plugin - Versions diffs - 2.2.0 → 2.3.0 - Mend

@rozenite/sqlite-plugin 2.2.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/dist/devtools/panel.html CHANGED Viewed

@@ -22,7 +22,7 @@
     <script>
       var __ROZENITE_PANEL__ = true;
     </script>
-    <script type="module" crossorigin src="../devtools/assets/panel-B2O8mY15.js"></script>
+    <script type="module" crossorigin src="../devtools/assets/panel-CLyprPq_.js"></script>
     <link rel="stylesheet" crossorigin href="../devtools/assets/panel-BarPLQ4-.css">
   </head>
   <body>

package/dist/react-native/cjs/package.json ADDED Viewed

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/react-native/cjs/react-native.js ADDED Viewed

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSqliteError = exports.decodeSqliteBridgeValue = exports.statementReturnsRows = exports.splitSqlStatements = exports.normalizeSingleStatementSql = exports.classifySqlStatement = exports.useRozeniteSqlitePlugin = exports.createExpoSqliteAdapter = exports.createSqliteAdapter = void 0;
+const isDev = process.env.NODE_ENV !== 'production';
+const isWeb = typeof window !== 'undefined' && window.navigator.product !== 'ReactNative';
+const isServer = typeof window === 'undefined' && typeof lynx === 'undefined';
+if (isDev && !isWeb && !isServer) {
+    exports.createSqliteAdapter = require('./src/react-native/adapters').createSqliteAdapter;
+    exports.createExpoSqliteAdapter = require('./src/react-native/adapters').createExpoSqliteAdapter;
+    exports.useRozeniteSqlitePlugin =
+        require('./src/react-native/useRozeniteSqlitePlugin').useRozeniteSqlitePlugin;
+    exports.classifySqlStatement = require('./src/shared/sql').classifySqlStatement;
+    exports.normalizeSingleStatementSql = require('./src/shared/sql').normalizeSingleStatementSql;
+    exports.splitSqlStatements = require('./src/shared/sql').splitSqlStatements;
+    exports.statementReturnsRows = require('./src/shared/sql').statementReturnsRows;
+    exports.decodeSqliteBridgeValue = require('./src/shared/bridge-values').decodeSqliteBridgeValue;
+    exports.formatSqliteError = require('./src/shared/bridge-values').formatSqliteError;
+}
+else {
+    exports.createSqliteAdapter = (options) => ({
+        id: options.adapterId ?? 'sqlite',
+        name: options.adapterName ?? 'SQLite',
+        databases: [],
+    });
+    exports.createExpoSqliteAdapter = (options) => ({
+        id: options.adapterId ?? 'expo-sqlite',
+        name: options.adapterName ?? 'Expo SQLite',
+        databases: [],
+    });
+    exports.useRozeniteSqlitePlugin = () => null;
+    exports.classifySqlStatement = () => 'other';
+    exports.normalizeSingleStatementSql = (sql) => sql;
+    exports.splitSqlStatements = () => [];
+    exports.statementReturnsRows = (_type) => false;
+    exports.decodeSqliteBridgeValue = (value) => value;
+    exports.formatSqliteError = () => 'Unknown SQLite error.';
+}

package/dist/react-native/cjs/src/react-native/adapters/expo-sqlite.js ADDED Viewed

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpoSqliteAdapter = void 0;
+const sql_1 = require("../../shared/sql");
+const bridge_values_1 = require("../../shared/bridge-values");
+const generic_1 = require("./generic");
+const now = () => typeof performance !== 'undefined' && typeof performance.now === 'function'
+    ? performance.now()
+    : Date.now();
+const safeError = (error) => (0, bridge_values_1.formatSqliteError)(error);
+const createExecuteStatementsError = (message, options = {}) => Object.assign(new Error(message), options);
+const toBridgeSafeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Array.from(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(value));
+    }
+    if (Array.isArray(value)) {
+        return value.map(toBridgeSafeValue);
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, toBridgeSafeValue(nestedValue)]));
+    }
+    return String(value);
+};
+const normalizeRows = (rows) => rows.map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, toBridgeSafeValue(value)])));
+const executeSingleStatement = async (database, { sql, params }) => {
+    const normalizedSql = (0, sql_1.normalizeSingleStatementSql)(sql);
+    const statementType = (0, sql_1.classifySqlStatement)(normalizedSql);
+    const startedAt = now();
+    const decodedParams = params === undefined ? undefined : (0, bridge_values_1.decodeSqliteBridgeValue)(params);
+    if ((0, sql_1.statementReturnsRows)(statementType)) {
+        const rows = normalizeRows(decodedParams === undefined
+            ? await database.getAllAsync(normalizedSql)
+            : await database.getAllAsync(normalizedSql, decodedParams));
+        const durationMs = now() - startedAt;
+        return {
+            rows,
+            columns: Object.keys(rows[0] ?? {}),
+            metadata: {
+                statementType,
+                rowCount: rows.length,
+                changes: null,
+                lastInsertRowId: null,
+                durationMs,
+            },
+        };
+    }
+    const result = decodedParams === undefined
+        ? await database.runAsync(normalizedSql)
+        : await database.runAsync(normalizedSql, decodedParams);
+    const durationMs = now() - startedAt;
+    return {
+        rows: [],
+        columns: [],
+        metadata: {
+            statementType,
+            rowCount: 0,
+            changes: typeof result.changes === 'number' ? result.changes : null,
+            lastInsertRowId: typeof result.lastInsertRowId === 'number' ? result.lastInsertRowId : null,
+            durationMs,
+        },
+    };
+};
+const createExpoExecuteStatementsRunner = (database) => {
+    return async (statements) => {
+        const results = [];
+        for (let index = 0; index < statements.length; index += 1) {
+            try {
+                results.push(await executeSingleStatement(database, statements[index]));
+            }
+            catch (error) {
+                throw createExecuteStatementsError(safeError(error), {
+                    completedResults: results,
+                    failedStatementIndex: index,
+                    cause: error,
+                });
+            }
+        }
+        return results;
+    };
+};
+const resolveDatabaseConfig = (config) => ('database' in config ? config : { database: config });
+const createExpoSqliteAdapter = (options) => {
+    const genericOptions = 'databases' in options
+        ? {
+            adapterId: options.adapterId ?? 'expo-sqlite',
+            adapterName: options.adapterName ?? 'Expo SQLite',
+            databases: Object.fromEntries(Object.entries(options.databases).map(([key, config]) => {
+                const resolved = resolveDatabaseConfig(config);
+                return [
+                    key,
+                    {
+                        name: resolved.name ?? key,
+                        executeStatements: createExpoExecuteStatementsRunner(resolved.database),
+                    },
+                ];
+            })),
+        }
+        : {
+            adapterId: options.adapterId ?? 'expo-sqlite',
+            adapterName: options.adapterName ?? 'Expo SQLite',
+            databaseName: options.databaseName,
+            database: (() => {
+                const resolved = resolveDatabaseConfig(options.database);
+                return {
+                    name: resolved.name ?? options.databaseName,
+                    executeStatements: createExpoExecuteStatementsRunner(resolved.database),
+                };
+            })(),
+        };
+    return (0, generic_1.createSqliteAdapter)(genericOptions);
+};
+exports.createExpoSqliteAdapter = createExpoSqliteAdapter;

package/dist/react-native/cjs/src/react-native/adapters/generic.js ADDED Viewed

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteAdapter = void 0;
+const slugify = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'database';
+const createDatabaseId = (adapterId, seed, index) => `${adapterId}__${slugify(seed)}__${index.toString(36)}`;
+const resolveDatabaseConfig = (config) => typeof config === 'function' ? { executeStatements: config } : config;
+const toDatabaseNode = (adapterId, databaseKey, config, index, fallbackName) => {
+    const resolved = resolveDatabaseConfig(config);
+    const name = resolved.name ?? fallbackName ?? databaseKey;
+    return {
+        id: createDatabaseId(adapterId, `${databaseKey}-${name}`, index),
+        name,
+        executeStatements: resolved.executeStatements,
+    };
+};
+const createSqliteAdapter = (options) => {
+    const { adapterId = 'sqlite', adapterName = 'SQLite' } = options;
+    const databases = 'databases' in options
+        ? Object.entries(options.databases).map(([key, config], index) => toDatabaseNode(adapterId, key, config, index))
+        : [
+            toDatabaseNode(adapterId, options.databaseName ?? 'default', options.database, 0, options.databaseName ?? 'Default Database'),
+        ];
+    return {
+        id: adapterId,
+        name: adapterName,
+        databases,
+    };
+};
+exports.createSqliteAdapter = createSqliteAdapter;

package/dist/react-native/cjs/src/react-native/adapters/index.js ADDED Viewed

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpoSqliteAdapter = exports.createSqliteAdapter = void 0;
+var generic_1 = require("./generic");
+Object.defineProperty(exports, "createSqliteAdapter", { enumerable: true, get: function () { return generic_1.createSqliteAdapter; } });
+var expo_sqlite_1 = require("./expo-sqlite");
+Object.defineProperty(exports, "createExpoSqliteAdapter", { enumerable: true, get: function () { return expo_sqlite_1.createExpoSqliteAdapter; } });

package/dist/react-native/cjs/src/react-native/sqlite-view.js ADDED Viewed

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqliteDatabaseViews = void 0;
+const createSqliteDatabaseViews = (adapters) => adapters.flatMap((adapter) => adapter.databases.map((database) => ({
+    id: database.id,
+    name: database.name,
+    adapterId: adapter.id,
+    adapterName: adapter.name,
+    executeStatements: database.executeStatements,
+})));
+exports.createSqliteDatabaseViews = createSqliteDatabaseViews;

package/dist/react-native/cjs/src/react-native/useRozeniteSqlitePlugin.js ADDED Viewed

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRozeniteSqlitePlugin = void 0;
+const plugin_bridge_1 = require("@rozenite/plugin-bridge");
+const react_1 = require("react");
+const bridge_values_1 = require("../shared/bridge-values");
+const protocol_1 = require("../shared/protocol");
+const sql_1 = require("../shared/sql");
+const sqlite_view_1 = require("./sqlite-view");
+const useSqliteAgentTools_1 = require("./useSqliteAgentTools");
+const safeError = (error) => (0, bridge_values_1.formatSqliteError)(error);
+const isExecuteStatementsError = (error) => error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
+const useRozeniteSqlitePlugin = ({ adapters }) => {
+    const views = (0, react_1.useMemo)(() => (0, sqlite_view_1.createSqliteDatabaseViews)(adapters), [adapters]);
+    (0, useSqliteAgentTools_1.useSqliteAgentTools)(views);
+    const client = (0, plugin_bridge_1.useRozeniteDevToolsClient)({
+        pluginId: protocol_1.PLUGIN_ID,
+    });
+    const subscriptionsRef = (0, react_1.useRef)([]);
+    const databaseQueuesRef = (0, react_1.useRef)(new Map());
+    (0, react_1.useEffect)(() => {
+        if (!client) {
+            return;
+        }
+        const enqueueDatabaseTask = async (databaseId, task) => {
+            const queue = databaseQueuesRef.current.get(databaseId) ?? Promise.resolve();
+            const next = queue.catch(() => undefined).then(task);
+            databaseQueuesRef.current.set(databaseId, next.then(() => undefined, () => undefined));
+            return next;
+        };
+        const resolveDatabase = (databaseId) => {
+            const database = views.find((view) => view.id === databaseId);
+            if (!database) {
+                throw new Error(`Unknown database "${databaseId}".`);
+            }
+            return database;
+        };
+        const executeStatements = async (databaseId, statements) => {
+            const database = resolveDatabase(databaseId);
+            const normalizedStatements = statements.map(({ sql, params }) => ({
+                sql: (0, sql_1.normalizeSingleStatementSql)(sql),
+                params,
+            }));
+            const results = await database.executeStatements(normalizedStatements);
+            if (results.length !== normalizedStatements.length) {
+                throw new Error(`Expected ${normalizedStatements.length} statement result(s), received ${results.length}.`);
+            }
+            return {
+                inputs: normalizedStatements,
+                results,
+            };
+        };
+        const executeSingleQuery = async (databaseId, sql, params) => {
+            const execution = await executeStatements(databaseId, [
+                {
+                    sql,
+                    params,
+                },
+            ]);
+            const result = execution.results[0];
+            if (!result) {
+                throw new Error('The query completed without a result payload.');
+            }
+            return result;
+        };
+        client.send('sqlite:ready', { timestamp: Date.now() });
+        subscriptionsRef.current.push(client.onMessage('sqlite:list-databases', ({ requestId }) => {
+            client.send('sqlite:list-databases:result', {
+                requestId,
+                databases: views.map(({ id, name, adapterId, adapterName }) => ({
+                    id,
+                    name,
+                    adapterId,
+                    adapterName,
+                })),
+            });
+        }));
+        subscriptionsRef.current.push(client.onMessage('sqlite:query', async ({ requestId, databaseId, sql, params }) => {
+            try {
+                const result = await enqueueDatabaseTask(databaseId, () => executeSingleQuery(databaseId, sql, params));
+                client.send('sqlite:query:result', {
+                    requestId,
+                    databaseId,
+                    result,
+                });
+            }
+            catch (error) {
+                client.send('sqlite:query:result', {
+                    requestId,
+                    databaseId,
+                    error: safeError(error),
+                });
+            }
+        }));
+        subscriptionsRef.current.push(client.onMessage('sqlite:execute-script', async ({ requestId, databaseId, sql }) => {
+            try {
+                const result = await enqueueDatabaseTask(databaseId, async () => {
+                    const statementSegments = (0, sql_1.splitSqlStatements)(sql);
+                    if (statementSegments.length === 0) {
+                        throw new Error('Query cannot be empty.');
+                    }
+                    const statementInputs = statementSegments.map((statement) => ({
+                        sql: statement.text,
+                    }));
+                    try {
+                        const execution = await executeStatements(databaseId, statementInputs);
+                        return {
+                            statements: statementSegments.map((statement, index) => ({
+                                index,
+                                start: statement.start,
+                                end: statement.end,
+                                input: execution.inputs[index],
+                                execution: {
+                                    input: execution.inputs[index],
+                                    result: execution.results[index],
+                                },
+                            })),
+                            totalStatementCount: statementSegments.length,
+                            failedStatementIndex: null,
+                        };
+                    }
+                    catch (error) {
+                        if (!isExecuteStatementsError(error)) {
+                            throw error;
+                        }
+                        const failedStatementIndex = Math.max(0, Math.min(typeof error.failedStatementIndex === 'number'
+                            ? error.failedStatementIndex
+                            : (error.completedResults?.length ?? 0), statementSegments.length - 1));
+                        const completedResults = (error.completedResults ?? []).slice(0, failedStatementIndex);
+                        const completedStatements = completedResults.map((queryResult, index) => ({
+                            index,
+                            start: statementSegments[index].start,
+                            end: statementSegments[index].end,
+                            input: statementInputs[index],
+                            execution: {
+                                input: statementInputs[index],
+                                result: queryResult,
+                            },
+                        }));
+                        return {
+                            statements: [
+                                ...completedStatements,
+                                {
+                                    index: failedStatementIndex,
+                                    start: statementSegments[failedStatementIndex].start,
+                                    end: statementSegments[failedStatementIndex].end,
+                                    input: statementInputs[failedStatementIndex],
+                                    error: safeError(error),
+                                },
+                            ],
+                            totalStatementCount: statementSegments.length,
+                            failedStatementIndex,
+                        };
+                    }
+                });
+                client.send('sqlite:execute-script:result', {
+                    requestId,
+                    databaseId,
+                    result,
+                });
+            }
+            catch (error) {
+                client.send('sqlite:execute-script:result', {
+                    requestId,
+                    databaseId,
+                    error: safeError(error),
+                });
+            }
+        }));
+        return () => {
+            subscriptionsRef.current.forEach((subscription) => subscription.remove());
+            subscriptionsRef.current = [];
+            databaseQueuesRef.current.clear();
+        };
+    }, [client, views]);
+    return client;
+};
+exports.useRozeniteSqlitePlugin = useRozeniteSqlitePlugin;

package/dist/react-native/cjs/src/react-native/useSqliteAgentTools.js ADDED Viewed

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSqliteAgentTools = void 0;
+const react_1 = require("react");
+const agent_bridge_1 = require("@rozenite/agent-bridge");
+const bridge_values_1 = require("../shared/bridge-values");
+const sql_1 = require("../shared/sql");
+const pluginId = '@rozenite/sqlite-plugin';
+const listDatabasesTool = {
+    name: 'list-databases',
+    description: 'List all registered SQLite databases.',
+    inputSchema: { type: 'object', properties: {} },
+};
+const executeSqlTool = {
+    name: 'execute-sql',
+    description: 'Execute one or more SQL statements against a database. Supports SELECT, INSERT, UPDATE, DELETE, PRAGMA, DDL, and multi-statement scripts. Returns per-statement results including rows, columns, and metadata. Statements are executed in order and stop on first error.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            databaseId: {
+                type: 'string',
+                description: 'Database ID from list-databases.',
+            },
+            sql: {
+                type: 'string',
+                description: 'SQL to execute. May contain multiple semicolon-separated statements.',
+            },
+        },
+        required: ['databaseId', 'sql'],
+    },
+};
+const isExecuteStatementsError = (error) => error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
+const useSqliteAgentTools = (views) => {
+    const resolveDatabase = (0, react_1.useCallback)((databaseId) => {
+        const database = views.find((view) => view.id === databaseId);
+        if (!database) {
+            const available = views.map((v) => v.id).join(', ');
+            throw new Error(`Unknown databaseId "${databaseId}". Available: ${available || '(none)'}`);
+        }
+        return database;
+    }, [views]);
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId,
+        tool: listDatabasesTool,
+        handler: () => ({
+            databases: views.map(({ id, name, adapterId, adapterName }) => ({
+                id,
+                name,
+                adapterId,
+                adapterName,
+            })),
+        }),
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId,
+        tool: executeSqlTool,
+        handler: async ({ databaseId, sql }) => {
+            const database = resolveDatabase(databaseId);
+            const statementSegments = (0, sql_1.splitSqlStatements)(sql);
+            if (statementSegments.length === 0) {
+                throw new Error('SQL cannot be empty.');
+            }
+            const statementInputs = statementSegments.map((segment) => ({
+                sql: (0, sql_1.normalizeSingleStatementSql)(segment.text),
+            }));
+            try {
+                const results = await database.executeStatements(statementInputs);
+                return {
+                    databaseId,
+                    totalStatementCount: statementSegments.length,
+                    failedStatementIndex: null,
+                    statements: statementSegments.map((_, index) => {
+                        const result = results[index];
+                        return {
+                            index,
+                            sql: statementInputs[index].sql,
+                            rows: result.rows,
+                            columns: result.columns,
+                            metadata: result.metadata,
+                        };
+                    }),
+                };
+            }
+            catch (error) {
+                if (!isExecuteStatementsError(error)) {
+                    throw new Error((0, bridge_values_1.formatSqliteError)(error));
+                }
+                const failedStatementIndex = Math.max(0, Math.min(typeof error.failedStatementIndex === 'number'
+                    ? error.failedStatementIndex
+                    : (error.completedResults?.length ?? 0), statementSegments.length - 1));
+                const completedResults = (error.completedResults ?? []).slice(0, failedStatementIndex);
+                return {
+                    databaseId,
+                    totalStatementCount: statementSegments.length,
+                    failedStatementIndex,
+                    statements: [
+                        ...completedResults.map((result, index) => ({
+                            index,
+                            sql: statementInputs[index].sql,
+                            rows: result.rows,
+                            columns: result.columns,
+                            metadata: result.metadata,
+                        })),
+                        {
+                            index: failedStatementIndex,
+                            sql: statementInputs[failedStatementIndex].sql,
+                            error: (0, bridge_values_1.formatSqliteError)(error),
+                        },
+                    ],
+                };
+            }
+        },
+    });
+};
+exports.useSqliteAgentTools = useSqliteAgentTools;

package/dist/react-native/cjs/src/shared/bridge-values.js ADDED Viewed

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSqliteError = exports.decodeSqliteBridgeValue = exports.encodeSqliteBridgeValue = void 0;
+const SQLITE_BRIDGE_BINARY_TYPE = '__rozeniteSqliteBinary';
+const isRecord = (value) => !!value && typeof value === 'object';
+const isEncodedBinaryValue = (value) => isRecord(value) &&
+    value[SQLITE_BRIDGE_BINARY_TYPE] === true &&
+    Array.isArray(value.data) &&
+    value.data.every((item) => typeof item === 'number');
+const encodeSqliteBridgeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            [SQLITE_BRIDGE_BINARY_TYPE]: true,
+            data: Array.from(value),
+        };
+    }
+    if (value instanceof ArrayBuffer) {
+        return {
+            [SQLITE_BRIDGE_BINARY_TYPE]: true,
+            data: Array.from(new Uint8Array(value)),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map(exports.encodeSqliteBridgeValue);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            (0, exports.encodeSqliteBridgeValue)(nestedValue),
+        ]));
+    }
+    return String(value);
+};
+exports.encodeSqliteBridgeValue = encodeSqliteBridgeValue;
+const decodeSqliteBridgeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (isEncodedBinaryValue(value)) {
+        return new Uint8Array(value.data);
+    }
+    if (Array.isArray(value)) {
+        return value.map(exports.decodeSqliteBridgeValue);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            (0, exports.decodeSqliteBridgeValue)(nestedValue),
+        ]));
+    }
+    return value;
+};
+exports.decodeSqliteBridgeValue = decodeSqliteBridgeValue;
+const getStringField = (value, key) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const field = value[key];
+    if (typeof field !== 'string') {
+        return null;
+    }
+    const trimmed = field.trim();
+    return trimmed ? trimmed : null;
+};
+const stringifyFallback = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const describeError = (error) => {
+    if (error instanceof Error) {
+        const code = getStringField(error, 'code');
+        const reason = getStringField(error, 'reason');
+        const message = error.message.trim();
+        const detailParts = [message || null, reason].filter((part, index, parts) => !!part && parts.indexOf(part) === index);
+        const detail = detailParts.join(' | ') || error.name;
+        return code ? `[${code}] ${detail}` : detail;
+    }
+    if (isRecord(error)) {
+        const code = getStringField(error, 'code');
+        const message = getStringField(error, 'message');
+        const reason = getStringField(error, 'reason');
+        const detail = message ?? reason ?? stringifyFallback(error);
+        return code ? `[${code}] ${detail}` : detail;
+    }
+    if (typeof error === 'string') {
+        return error.trim() || null;
+    }
+    if (error == null) {
+        return null;
+    }
+    return stringifyFallback(error);
+};
+const getCause = (error) => {
+    if (!isRecord(error)) {
+        return undefined;
+    }
+    return error.cause;
+};
+const formatSqliteError = (error) => {
+    const visited = new Set();
+    const parts = [];
+    let current = error;
+    while (current !== undefined && current !== null && !visited.has(current)) {
+        visited.add(current);
+        const description = describeError(current);
+        if (description && !parts.includes(description)) {
+            parts.push(description);
+        }
+        current = getCause(current);
+    }
+    return parts.join('\nCaused by: ') || 'Unknown SQLite error.';
+};
+exports.formatSqliteError = formatSqliteError;

package/dist/react-native/cjs/src/shared/protocol.js ADDED Viewed

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_ID = void 0;
+exports.PLUGIN_ID = '@rozenite/sqlite-plugin';