@rozenite/storage-plugin 2.2.0 → 2.3.0

package/dist/react-native/cjs/src/react-native/useStorageAgentTools.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStorageAgentTools = exports.createStorageAgentHandlers = void 0;
+const agent_bridge_1 = require("@rozenite/agent-bridge");
+const agent_shared_1 = require("@rozenite/agent-shared");
+const agent_tools_1 = require("../shared/agent-tools");
+const parseValueForType = (type, value) => {
+    if (type === 'string') {
+        if (typeof value !== 'string') {
+            throw new Error('Expected string value for type=string');
+        }
+        return value;
+    }
+    if (type === 'number') {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+            throw new Error('Expected number value for type=number');
+        }
+        return value;
+    }
+    if (type === 'boolean') {
+        if (typeof value !== 'boolean') {
+            throw new Error('Expected boolean value for type=boolean');
+        }
+        return value;
+    }
+    if (!Array.isArray(value) || !value.every((item) => Number.isInteger(item))) {
+        throw new Error('Expected number[] value for type=buffer');
+    }
+    return value;
+};
+const formatViewRef = (view) => `${view.target.adapterId}/${view.target.storageId}`;
+const isSameTarget = (left, right) => left.adapterId === right.adapterId && left.storageId === right.storageId;
+const encodeCursor = (cursor) => btoa(encodeURIComponent(JSON.stringify(cursor)));
+const decodeCursor = (value) => {
+    try {
+        const cursor = JSON.parse(decodeURIComponent(atob(value)));
+        if (typeof cursor !== 'object' ||
+            cursor == null ||
+            Array.isArray(cursor) ||
+            cursor.version !== 1 ||
+            typeof cursor.target?.adapterId !== 'string' ||
+            typeof cursor.target?.storageId !== 'string' ||
+            !Number.isSafeInteger(cursor.offset) ||
+            cursor.offset < 0) {
+            throw new Error('Invalid cursor');
+        }
+        return cursor;
+    }
+    catch {
+        throw new Error('Invalid cursor. Run list-entries again without a cursor to restart pagination.');
+    }
+};
+const sanitizeLimit = (limit) => {
+    if (typeof limit !== 'number' ||
+        !Number.isFinite(limit) ||
+        !Number.isInteger(limit) ||
+        limit < 1) {
+        return agent_shared_1.DEFAULT_PAGE_LIMIT;
+    }
+    return Math.min(limit, agent_shared_1.MAX_PAGE_LIMIT);
+};
+const sanitizeOffset = (offset) => {
+    if (typeof offset !== 'number' ||
+        !Number.isFinite(offset) ||
+        !Number.isSafeInteger(offset) ||
+        offset < 0) {
+        return 0;
+    }
+    return offset;
+};
+const resolveStorage = (views, adapterId, storageId) => {
+    if (views.length === 0) {
+        throw new Error('No storages are registered.');
+    }
+    if (adapterId !== undefined || storageId !== undefined) {
+        const matches = views.filter((view) => (adapterId === undefined || view.target.adapterId === adapterId) &&
+            (storageId === undefined || view.target.storageId === storageId));
+        const qualifier = [
+            adapterId !== undefined && `adapterId="${adapterId}"`,
+            storageId !== undefined && `storageId="${storageId}"`,
+        ]
+            .filter(Boolean)
+            .join(', ');
+        if (matches.length === 0) {
+            throw new Error(`No storage matched ${qualifier}. Available: ${views.map(formatViewRef).join(', ')}`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`Multiple storages matched ${qualifier}. Provide both adapterId and storageId. Available: ${matches.map(formatViewRef).join(', ')}`);
+        }
+        return matches[0];
+    }
+    if (views.length > 1) {
+        throw new Error(`Multiple storages detected. Provide adapterId and/or storageId. Available: ${views.map(formatViewRef).join(', ')}`);
+    }
+    return views[0];
+};
+const listStorageKeys = async (view, input) => {
+    const limit = sanitizeLimit(input.limit);
+    if (input.cursor !== undefined && input.offset !== undefined) {
+        throw new Error('Provide either cursor or offset, not both.');
+    }
+    const cursor = input.cursor === undefined ? undefined : decodeCursor(input.cursor);
+    if (cursor && !isSameTarget(cursor.target, view.target)) {
+        throw new Error('Cursor does not match the requested storage. Run list-entries again without a cursor to restart pagination.');
+    }
+    const allKeys = await view.getAllKeys();
+    const offset = cursor?.offset ?? sanitizeOffset(input.offset);
+    const end = Math.min(offset + limit, allKeys.length);
+    return {
+        adapterId: view.target.adapterId,
+        storageId: view.target.storageId,
+        total: allKeys.length,
+        items: allKeys.slice(offset, end).map((key) => ({ key })),
+        page: {
+            limit,
+            hasMore: end < allKeys.length,
+            ...(end < allKeys.length
+                ? {
+                    nextCursor: encodeCursor({
+                        version: 1,
+                        target: view.target,
+                        offset: end,
+                    }),
+                }
+                : {}),
+        },
+    };
+};
+const createStorageAgentHandlers = (views) => ({
+    listStorages: async () => ({
+        storages: views.map((view) => ({
+            adapterId: view.target.adapterId,
+            storageId: view.target.storageId,
+            adapterName: view.adapterName,
+            storageName: view.storageName,
+            supportedTypes: view.capabilities.supportedTypes,
+        })),
+    }),
+    listEntries: async (input) => {
+        const view = resolveStorage(views, input.adapterId, input.storageId);
+        return listStorageKeys(view, input);
+    },
+    readEntry: async ({ adapterId, storageId, key, }) => {
+        const view = resolveStorage(views, adapterId, storageId);
+        const entry = await view.get(key);
+        if (!entry) {
+            throw new Error(`Key "${key}" not found in storage "${formatViewRef(view)}".`);
+        }
+        return {
+            adapterId: view.target.adapterId,
+            storageId: view.target.storageId,
+            entry,
+        };
+    },
+});
+exports.createStorageAgentHandlers = createStorageAgentHandlers;
+const useStorageAgentTools = (views) => {
+    const handlers = (0, exports.createStorageAgentHandlers)(views);
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.listStorages,
+        handler: handlers.listStorages,
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.listEntries,
+        handler: handlers.listEntries,
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.readEntry,
+        handler: handlers.readEntry,
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.createEntry,
+        handler: async ({ adapterId, storageId, key, type, value }) => {
+            const view = resolveStorage(views, adapterId, storageId);
+            const existing = await view.get(key);
+            if (existing) {
+                throw new Error(`Key "${key}" already exists in storage "${formatViewRef(view)}". Use edit-entry instead.`);
+            }
+            const parsedValue = parseValueForType(type, value);
+            await view.set({ key, type, value: parsedValue });
+            return {
+                adapterId: view.target.adapterId,
+                storageId: view.target.storageId,
+                created: true,
+                key,
+            };
+        },
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.editEntry,
+        handler: async ({ adapterId, storageId, key, type, value }) => {
+            const view = resolveStorage(views, adapterId, storageId);
+            const existing = await view.get(key);
+            if (!existing) {
+                throw new Error(`Key "${key}" not found in storage "${formatViewRef(view)}". Use create-entry instead.`);
+            }
+            const parsedValue = parseValueForType(type, value);
+            await view.set({ key, type, value: parsedValue });
+            return {
+                adapterId: view.target.adapterId,
+                storageId: view.target.storageId,
+                edited: true,
+                key,
+            };
+        },
+    });
+    (0, agent_bridge_1.useRozenitePluginAgentTool)({
+        pluginId: agent_tools_1.STORAGE_AGENT_PLUGIN_ID,
+        tool: agent_tools_1.storageToolDefinitions.removeEntry,
+        handler: async ({ adapterId, storageId, key }) => {
+            const view = resolveStorage(views, adapterId, storageId);
+            const existed = !!(await view.get(key));
+            await view.delete(key);
+            return {
+                adapterId: view.target.adapterId,
+                storageId: view.target.storageId,
+                removed: existed,
+                key,
+            };
+        },
+    });
+};
+exports.useStorageAgentTools = useStorageAgentTools;

package/dist/react-native/cjs/src/shared/agent-tools.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageToolDefinitions = exports.STORAGE_AGENT_ENTRY_TYPES = exports.STORAGE_AGENT_PLUGIN_ID = void 0;
+const agent_shared_1 = require("@rozenite/agent-shared");
+const sharedStorageProperties = {
+    adapterId: {
+        type: 'string',
+        description: 'Storage adapter ID. Required when multiple adapters are configured.',
+    },
+    storageId: {
+        type: 'string',
+        description: 'Storage node ID within the adapter. Required when multiple storages are configured.',
+    },
+};
+exports.STORAGE_AGENT_PLUGIN_ID = '@rozenite/storage-plugin';
+exports.STORAGE_AGENT_ENTRY_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'buffer',
+];
+exports.storageToolDefinitions = {
+    listStorages: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'list-storages',
+        description: 'List all storage adapters and their storage nodes currently available on the device, including supported entry types. Entry counts are omitted to avoid enumerating every storage.',
+        inputSchema: { type: 'object', properties: {} },
+    }),
+    listEntries: (0, agent_shared_1.definePaginatedAgentToolContract)({
+        name: 'list-entries',
+        description: 'List keys in a storage. This call intentionally does not return entry values to keep responses token-efficient.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                limit: {
+                    type: 'number',
+                    description: 'Pagination size. Defaults to 20 and is capped at 100.',
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Opaque pagination cursor from a previous list-entries call.',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Deprecated initial pagination offset. Must be a non-negative integer and cannot be combined with cursor.',
+                },
+            },
+        },
+        pagination: {
+            kind: 'cursor',
+            fields: ['key'],
+            defaultFields: ['key'],
+        },
+    }),
+    readEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'read-entry',
+        description: 'Read a single storage entry value by key.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+            },
+            required: ['key'],
+        },
+    }),
+    createEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'create-entry',
+        description: 'Create a new storage entry. Fails if the key already exists.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+                type: {
+                    type: 'string',
+                    enum: [...exports.STORAGE_AGENT_ENTRY_TYPES],
+                    description: 'Entry value type. Must be one of the supported types for the target storage (see list-storages).',
+                },
+                value: {
+                    description: 'Entry value matching the provided type.',
+                },
+            },
+            required: ['key', 'type', 'value'],
+        },
+    }),
+    editEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'edit-entry',
+        description: 'Edit an existing storage entry. Fails if the key does not exist.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+                type: {
+                    type: 'string',
+                    enum: [...exports.STORAGE_AGENT_ENTRY_TYPES],
+                    description: 'Entry value type. Must be one of the supported types for the target storage (see list-storages).',
+                },
+                value: {
+                    description: 'Entry value matching the provided type.',
+                },
+            },
+            required: ['key', 'type', 'value'],
+        },
+    }),
+    removeEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'remove-entry',
+        description: 'Remove a storage entry by key.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+            },
+            required: ['key'],
+        },
+    }),
+};

package/dist/react-native/cjs/src/shared/entry-preview.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStorageEntryPreview = exports.MAX_BUFFER_PREVIEW_BYTES = exports.MAX_STRING_PREVIEW_CODE_POINTS = void 0;
+exports.MAX_STRING_PREVIEW_CODE_POINTS = 256;
+exports.MAX_BUFFER_PREVIEW_BYTES = 16;
+const toHexPair = (byte) => byte.toString(16).toUpperCase().padStart(2, '0');
+const truncateString = (value) => {
+    let preview = '';
+    let codePointCount = 0;
+    for (const codePoint of value) {
+        if (codePointCount === exports.MAX_STRING_PREVIEW_CODE_POINTS) {
+            return { preview, isTruncated: true };
+        }
+        preview += codePoint;
+        codePointCount += 1;
+    }
+    return { preview, isTruncated: false };
+};
+const toStorageEntryPreview = (entry) => {
+    if (entry.type === 'string') {
+        return {
+            key: entry.key,
+            type: entry.type,
+            ...truncateString(entry.value),
+            // JavaScript strings expose their length in UTF-16 code units.
+            valueSize: entry.value.length,
+        };
+    }
+    if (entry.type === 'buffer') {
+        const shownBytes = entry.value.slice(0, exports.MAX_BUFFER_PREVIEW_BYTES);
+        return {
+            key: entry.key,
+            type: entry.type,
+            preview: shownBytes.map(toHexPair).join(' '),
+            valueSize: entry.value.length,
+            isTruncated: entry.value.length > exports.MAX_BUFFER_PREVIEW_BYTES,
+        };
+    }
+    const preview = String(entry.value);
+    return {
+        key: entry.key,
+        type: entry.type,
+        preview,
+        valueSize: preview.length,
+        isTruncated: false,
+    };
+};
+exports.toStorageEntryPreview = toStorageEntryPreview;

package/dist/react-native/cjs/src/shared/messaging.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/react-native/cjs/src/shared/snapshot.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePreview = exports.buildSnapshot = exports.parseSnapshot = void 0;
+const types_1 = require("./types");
+const PLUGIN_ID = '@rozenite/storage-plugin';
+const SUPPORTED_VERSION = 1;
+class ParseException extends Error {
+    constructor(path, message) {
+        super(message);
+        this.path = path;
+    }
+}
+const describe = (value) => {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+};
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const expectObject = (value, path) => {
+    if (!isPlainObject(value)) {
+        throw new ParseException(path, `Expected object, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectString = (value, path) => {
+    if (typeof value !== 'string') {
+        throw new ParseException(path, `Expected string, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectArray = (value, path) => {
+    if (!Array.isArray(value)) {
+        throw new ParseException(path, `Expected array, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectEntryType = (value, path) => {
+    if (typeof value !== 'string' || !types_1.DEFAULT_SUPPORTED_TYPES.includes(value)) {
+        throw new ParseException(path, `Expected one of ${types_1.DEFAULT_SUPPORTED_TYPES.join(', ')}, got ${describe(value)}`);
+    }
+    return value;
+};
+const parseCapabilities = (raw, path) => {
+    const obj = expectObject(raw, path);
+    const supported = expectArray(obj.supportedTypes, `${path}.supportedTypes`);
+    const supportedTypes = supported.map((type, index) => expectEntryType(type, `${path}.supportedTypes[${index}]`));
+    return { supportedTypes };
+};
+const parseStorageMeta = (raw) => {
+    const obj = expectObject(raw, 'storage');
+    return {
+        adapterId: expectString(obj.adapterId, 'storage.adapterId'),
+        storageId: expectString(obj.storageId, 'storage.storageId'),
+        adapterName: expectString(obj.adapterName, 'storage.adapterName'),
+        storageName: expectString(obj.storageName, 'storage.storageName'),
+        capabilities: parseCapabilities(obj.capabilities, 'storage.capabilities'),
+    };
+};
+const parseEntry = (raw, path) => {
+    const obj = expectObject(raw, path);
+    const key = expectString(obj.key, `${path}.key`);
+    const type = expectEntryType(obj.type, `${path}.type`);
+    const valuePath = `${path}.value`;
+    switch (type) {
+        case 'string': {
+            const value = obj.value;
+            if (typeof value !== 'string') {
+                throw new ParseException(valuePath, `Expected string for type "string", got ${describe(value)}`);
+            }
+            return { key, type: 'string', value };
+        }
+        case 'number': {
+            const value = obj.value;
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new ParseException(valuePath, `Expected finite number for type "number", got ${describe(value)}`);
+            }
+            return { key, type: 'number', value };
+        }
+        case 'boolean': {
+            const value = obj.value;
+            if (typeof value !== 'boolean') {
+                throw new ParseException(valuePath, `Expected boolean for type "boolean", got ${describe(value)}`);
+            }
+            return { key, type: 'boolean', value };
+        }
+        case 'buffer': {
+            const value = obj.value;
+            if (!Array.isArray(value)) {
+                throw new ParseException(valuePath, `Expected number[] for type "buffer", got ${describe(value)}`);
+            }
+            const bytes = value.map((byte, index) => {
+                if (typeof byte !== 'number' || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+                    throw new ParseException(`${valuePath}[${index}]`, `Expected uint8 (integer 0-255), got ${describe(byte)}`);
+                }
+                return byte;
+            });
+            return { key, type: 'buffer', value: bytes };
+        }
+    }
+};
+const parseSnapshot = (raw) => {
+    try {
+        const root = expectObject(raw, '$');
+        const version = root.version;
+        if (version !== SUPPORTED_VERSION) {
+            throw new ParseException('version', `Unsupported snapshot version: ${describe(version)} (this build supports version ${SUPPORTED_VERSION})`);
+        }
+        const plugin = expectString(root.plugin, 'plugin');
+        const createdAt = expectString(root.createdAt, 'createdAt');
+        const storage = parseStorageMeta(root.storage);
+        const rawEntries = expectArray(root.entries, 'entries');
+        const entries = rawEntries.map((entry, index) => parseEntry(entry, `entries[${index}]`));
+        return {
+            ok: true,
+            snapshot: {
+                version: SUPPORTED_VERSION,
+                plugin,
+                createdAt,
+                storage,
+                entries,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ParseException) {
+            return { ok: false, error: { path: error.path, message: error.message } };
+        }
+        throw error;
+    }
+};
+exports.parseSnapshot = parseSnapshot;
+const buildSnapshot = (args) => ({
+    version: 1,
+    plugin: PLUGIN_ID,
+    createdAt: new Date().toISOString(),
+    storage: {
+        adapterId: args.target.adapterId,
+        storageId: args.target.storageId,
+        adapterName: args.adapterName,
+        storageName: args.storageName,
+        capabilities: args.capabilities,
+    },
+    entries: args.entries,
+});
+exports.buildSnapshot = buildSnapshot;
+const computePreview = (snapshot, current) => {
+    const newKeys = [];
+    const overwriteKeys = [];
+    const skippedKeys = [];
+    const unsupportedTypes = [];
+    const acceptedEntryIndexes = [];
+    for (const [index, entry] of snapshot.entries.entries()) {
+        if (!(0, types_1.supportsType)(current.capabilities, entry.type)) {
+            unsupportedTypes.push({ key: entry.key, type: entry.type });
+            continue;
+        }
+        if (current.isBlacklisted(entry.key)) {
+            skippedKeys.push({ key: entry.key, reason: 'blacklist' });
+            continue;
+        }
+        if (current.entryKeys.has(entry.key)) {
+            overwriteKeys.push(entry.key);
+        }
+        else {
+            newKeys.push(entry.key);
+        }
+        acceptedEntryIndexes.push(index);
+        // Duplicate keys are applied in source order, so every accepted duplicate
+        // after the first overwrites the value that preceded it in this import.
+        current.entryKeys.add(entry.key);
+    }
+    const metadataMismatch = snapshot.storage.adapterId !== current.target.adapterId ||
+        snapshot.storage.storageId !== current.target.storageId;
+    return {
+        newKeys,
+        overwriteKeys,
+        skippedKeys,
+        unsupportedTypes,
+        acceptedEntryIndexes,
+        metadataMismatch,
+    };
+};
+exports.computePreview = computePreview;

package/dist/react-native/cjs/src/shared/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsType = exports.getStorageViewId = exports.DEFAULT_SUPPORTED_TYPES = void 0;
+exports.DEFAULT_SUPPORTED_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'buffer',
+];
+const getStorageViewId = ({ adapterId, storageId }) => `${adapterId}:${storageId}`;
+exports.getStorageViewId = getStorageViewId;
+const supportsType = (capabilities, type) => capabilities.supportedTypes.includes(type);
+exports.supportsType = supportsType;

package/dist/react-native/package.json

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

package/dist/react-native/react-native.d.ts

@@ -0,0 +1,7 @@
+export type { AsyncStorageInstanceConfig, AsyncStorageLike, CreateAsyncStorageAdapterOptions, CreateExpoAsyncStorageAdapterOptions, CreateExpoSecureStorageAdapterOptions, CreateMMKVStorageAdapterOptions, SecureStorageLike, } from './src/react-native/adapters';
+export type { AsyncStorage, StorageAdapter, StorageCapabilities, StorageEntry, StorageEntryType, StorageEntryValue, StorageNode, SyncStorage, } from './src/shared/types';
+export declare let createAsyncStorageAdapter: typeof import('./src/react-native/adapters').createAsyncStorageAdapter;
+export declare let createExpoAsyncStorageAdapter: typeof import('./src/react-native/adapters').createExpoAsyncStorageAdapter;
+export declare let createExpoSecureStorageAdapter: typeof import('./src/react-native/adapters').createExpoSecureStorageAdapter;
+export declare let createMMKVStorageAdapter: typeof import('./src/react-native/adapters').createMMKVStorageAdapter;
+export declare let useRozeniteStoragePlugin: typeof import('./src/react-native/useRozeniteStoragePlugin').useRozeniteStoragePlugin;

package/dist/react-native/react-native.js

@@ -0,0 +1,40 @@
+export let createAsyncStorageAdapter;
+export let createExpoAsyncStorageAdapter;
+export let createExpoSecureStorageAdapter;
+export let createMMKVStorageAdapter;
+export let useRozeniteStoragePlugin;
+const isWeb = typeof window !== 'undefined' && window.navigator.product !== 'ReactNative';
+const isDev = process.env.NODE_ENV !== 'production';
+const isServer = typeof window === 'undefined' && typeof lynx === 'undefined';
+const createNoopStorageAdapter = (options, defaultId, defaultName) => ({
+    id: options?.adapterId ?? defaultId,
+    name: options?.adapterName ?? defaultName,
+    storages: [],
+});
+if (!isDev || isServer) {
+    createAsyncStorageAdapter = ((options) => createNoopStorageAdapter(options, 'async-storage', 'AsyncStorage'));
+    createExpoAsyncStorageAdapter = createAsyncStorageAdapter;
+    createExpoSecureStorageAdapter = ((options) => createNoopStorageAdapter(options, 'expo-secure-store', 'Expo SecureStore'));
+    createMMKVStorageAdapter = ((options) => createNoopStorageAdapter(options, 'mmkv', 'MMKV'));
+    useRozeniteStoragePlugin = () => null;
+}
+else if (isWeb) {
+    const asyncStorageModule = require('./src/react-native/adapters/async-storage');
+    const secureStorageModule = require('./src/react-native/adapters/secure-storage');
+    createAsyncStorageAdapter = asyncStorageModule.createAsyncStorageAdapter;
+    createExpoAsyncStorageAdapter = asyncStorageModule.createExpoAsyncStorageAdapter;
+    createExpoSecureStorageAdapter = secureStorageModule.createExpoSecureStorageAdapter;
+    createMMKVStorageAdapter = ((options) => createNoopStorageAdapter(options, 'mmkv', 'MMKV'));
+    useRozeniteStoragePlugin =
+        require('./src/react-native/useRozeniteStoragePlugin').useRozeniteStoragePlugin;
+}
+else {
+    createAsyncStorageAdapter = require('./src/react-native/adapters').createAsyncStorageAdapter;
+    createExpoAsyncStorageAdapter =
+        require('./src/react-native/adapters').createExpoAsyncStorageAdapter;
+    createExpoSecureStorageAdapter =
+        require('./src/react-native/adapters').createExpoSecureStorageAdapter;
+    createMMKVStorageAdapter = require('./src/react-native/adapters').createMMKVStorageAdapter;
+    useRozeniteStoragePlugin =
+        require('./src/react-native/useRozeniteStoragePlugin').useRozeniteStoragePlugin;
+}