meridian-react-native 0.4.0

package/dist/index.cjs

@@ -0,0 +1,416 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRNClient: () => createRNClient,
+  defineSchema: () => import_meridian_shared2.defineSchema,
+  useDoc: () => useDoc,
+  useLiveQuery: () => useLiveQuery,
+  useMutation: () => useMutation,
+  usePresence: () => usePresence,
+  useQuery: () => useQuery,
+  useQueryOptimized: () => useQueryOptimized,
+  useSync: () => useSync,
+  z: () => import_meridian_shared2.z
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rn-client.ts
+var import_meridian_shared = require("meridian-shared");
+var AsyncKVStore = class {
+  memoryFallback = /* @__PURE__ */ new Map();
+  async get(key) {
+    try {
+      const AsyncStorage = require("@react-native-async-storage/async-storage").default;
+      return await AsyncStorage.getItem(`meridian:${key}`);
+    } catch {
+      return this.memoryFallback.get(key) ?? null;
+    }
+  }
+  async set(key, value) {
+    try {
+      const AsyncStorage = require("@react-native-async-storage/async-storage").default;
+      await AsyncStorage.setItem(`meridian:${key}`, value);
+    } catch {
+      this.memoryFallback.set(key, value);
+    }
+  }
+  async delete(key) {
+    try {
+      const AsyncStorage = require("@react-native-async-storage/async-storage").default;
+      await AsyncStorage.removeItem(`meridian:${key}`);
+    } catch {
+      this.memoryFallback.delete(key);
+    }
+  }
+  async keys() {
+    try {
+      const AsyncStorage = require("@react-native-async-storage/async-storage").default;
+      const allKeys = await AsyncStorage.getAllKeys();
+      return allKeys.filter((k) => k.startsWith("meridian:")).map((k) => k.replace("meridian:", ""));
+    } catch {
+      return Array.from(this.memoryFallback.keys());
+    }
+  }
+};
+function createRNClient(config) {
+  const { schema, serverUrl, auth, debug = false } = config;
+  const nodeId = (0, import_meridian_shared.generateNodeId)();
+  const clock = new import_meridian_shared.HLC(nodeId);
+  const store = new AsyncKVStore();
+  const collections = {};
+  let ws = null;
+  let state = "disconnected";
+  let destroyed = false;
+  for (const name of Object.keys(schema.collections)) {
+    const proxy = new RNCollectionProxy(name, store, clock, () => ws, serverUrl, auth, debug);
+    collections[name] = proxy;
+  }
+  connect().catch(() => {
+  });
+  async function connect() {
+    if (destroyed) return;
+    state = "connecting";
+    try {
+      ws = new WebSocket(serverUrl);
+      ws.onopen = async () => {
+        state = "connected";
+        if (auth) {
+          const token = await auth.getToken();
+          ws?.send(JSON.stringify({ type: "auth", token }));
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "ack" && msg.opIds) {
+            for (const id of msg.opIds) {
+              store.delete(`pending:${id}`).catch(() => {
+              });
+            }
+          }
+        } catch {
+        }
+      };
+      ws.onerror = () => {
+        state = "error";
+      };
+      ws.onclose = () => {
+        state = "disconnected";
+        if (!destroyed) setTimeout(connect, 3e3);
+      };
+    } catch {
+      state = "disconnected";
+      if (!destroyed) setTimeout(connect, 5e3);
+    }
+  }
+  const client = {
+    get connectionState() {
+      return state;
+    },
+    async sync() {
+      if (ws && state === "connected") {
+        const pendingKeys = await store.keys();
+        const ops = [];
+        for (const key of pendingKeys) {
+          if (key.startsWith("pending:")) {
+            const opJson = await store.get(key);
+            if (opJson) ops.push(JSON.parse(opJson));
+          }
+        }
+        if (ops.length > 0) {
+          ws.send(JSON.stringify({ type: "push", ops }));
+        }
+      }
+    },
+    destroy() {
+      destroyed = true;
+      if (ws) {
+        ws.onclose = null;
+        ws.close();
+        ws = null;
+      }
+    }
+  };
+  for (const [name, proxy] of Object.entries(collections)) {
+    client[name] = proxy;
+  }
+  return client;
+}
+var RNCollectionProxy = class {
+  collection;
+  store;
+  clock;
+  getWs;
+  serverUrl;
+  auth;
+  debug;
+  constructor(collection, store, clock, getWs, serverUrl, auth, debug) {
+    this.collection = collection;
+    this.store = store;
+    this.clock = clock;
+    this.getWs = getWs;
+    this.serverUrl = serverUrl;
+    this.auth = auth;
+    this.debug = debug;
+  }
+  find(filter) {
+    const self = this;
+    const listeners = /* @__PURE__ */ new Set();
+    return {
+      subscribe(cb) {
+        listeners.add(cb);
+        self.queryDocs(filter).then(cb);
+        return () => {
+          listeners.delete(cb);
+        };
+      },
+      get: () => self.queryDocs(filter)
+    };
+  }
+  findOne(id) {
+    return {
+      subscribe: (cb) => {
+        this.getDoc(id).then(cb);
+        return () => {
+        };
+      },
+      get: () => this.getDoc(id)
+    };
+  }
+  live(options = {}) {
+    return this.find(options.where);
+  }
+  async put(doc) {
+    if (!doc.id) doc.id = `rn-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const hlcTs = this.clock.now();
+    const hlcStr = `${hlcTs.wallTime}-${hlcTs.counter.toString().padStart(4, "0")}-${hlcTs.nodeId}`;
+    await this.store.set(`doc:${this.collection}:${doc.id}`, JSON.stringify(doc));
+    await this.queueOp(doc.id, Object.keys(doc).filter((k) => k !== "id"), doc, hlcStr);
+    this.trySync();
+  }
+  async update(id, fields) {
+    const existing = await this.getDoc(id);
+    if (!existing) return;
+    const merged = { ...existing, ...fields };
+    await this.store.set(`doc:${this.collection}:${id}`, JSON.stringify(merged));
+    const hlcTs = this.clock.now();
+    const hlcStr = `${hlcTs.wallTime}-${hlcTs.counter.toString().padStart(4, "0")}-${hlcTs.nodeId}`;
+    await this.queueOp(id, Object.keys(fields), fields, hlcStr);
+    this.trySync();
+  }
+  async delete(id) {
+    await this.store.set(`doc:${this.collection}:${id}:deleted`, "true");
+    this.trySync();
+  }
+  async queryDocs(filter) {
+    const allKeys = await this.store.keys();
+    const docs = [];
+    for (const key of allKeys) {
+      if (!key.startsWith(`doc:${this.collection}:`)) continue;
+      const id = key.split(":").pop();
+      const deleted = await this.store.get(`doc:${this.collection}:${id}:deleted`);
+      if (deleted === "true") continue;
+      const raw = await this.store.get(key);
+      if (!raw) continue;
+      const doc = JSON.parse(raw);
+      if (filter) {
+        let matches = true;
+        for (const [k, v] of Object.entries(filter)) {
+          if (doc[k] !== v) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      docs.push(doc);
+    }
+    return docs;
+  }
+  async getDoc(id) {
+    const raw = await this.store.get(`doc:${this.collection}:${id}`);
+    if (!raw) return null;
+    return JSON.parse(raw);
+  }
+  async queueOp(docId, fields, values, hlc) {
+    for (const field of fields) {
+      const op = {
+        id: `${docId}-${field}-${hlc}`,
+        collection: this.collection,
+        docId,
+        field,
+        value: values[field],
+        hlc,
+        nodeId: this.clock.peek().nodeId
+      };
+      await this.store.set(`pending:${op.id}`, JSON.stringify(op));
+    }
+  }
+  trySync() {
+    const ws = this.getWs();
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    this.store.keys().then(async (keys) => {
+      const ops = [];
+      for (const key of keys) {
+        if (key.startsWith("pending:")) {
+          const raw = await this.store.get(key);
+          if (raw) ops.push(JSON.parse(raw));
+        }
+      }
+      if (ops.length > 0) {
+        ws.send(JSON.stringify({ type: "push", ops }));
+      }
+    });
+  }
+};
+
+// src/hooks.ts
+var import_react = require("react");
+function useQuery(query) {
+  const [data, setData] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
+    let mounted = true;
+    const unsub = query.subscribe((result) => {
+      if (mounted) setData(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, []);
+  return data;
+}
+function useLiveQuery(collection, options = {}) {
+  const [data, setData] = (0, import_react.useState)();
+  const { where: _w, orderBy: _ob, limit: _lim } = options;
+  const depKey = `${_ob || ""}-${_lim || 0}-${Object.entries(_w || {}).sort().join(",")}`;
+  (0, import_react.useEffect)(() => {
+    const query = collection.live(options);
+    let mounted = true;
+    const unsub = query.subscribe((result) => {
+      if (mounted) setData(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, [depKey]);
+  return data;
+}
+function useDoc(collection, docId) {
+  const [doc, setDoc] = (0, import_react.useState)();
+  (0, import_react.useEffect)(() => {
+    if (!docId) {
+      setDoc(null);
+      return;
+    }
+    let mounted = true;
+    const unsub = collection.findOne(docId).subscribe((result) => {
+      if (mounted) setDoc(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, [docId]);
+  return doc;
+}
+function useSync(client) {
+  const [state, setState] = (0, import_react.useState)({ connected: false, pendingCount: 0 });
+  (0, import_react.useEffect)(() => {
+    const interval = setInterval(() => {
+      setState({ connected: client.connectionState === "connected", pendingCount: 0 });
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  return state;
+}
+function usePresence(_client) {
+  return {};
+}
+function useMutation(collection) {
+  return {
+    put: (0, import_react.useCallback)((doc) => collection.put(doc), []),
+    update: (0, import_react.useCallback)((id, fields) => collection.update(id, fields), []),
+    remove: (0, import_react.useCallback)((id) => collection.delete(id), [])
+  };
+}
+function shallowEqual(a, b) {
+  const ka = Object.keys(a), kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (const k of ka) if (a[k] !== b[k]) return false;
+  return true;
+}
+function useQueryOptimized(query) {
+  const [docMap, setDocMap] = (0, import_react.useState)(/* @__PURE__ */ new Map());
+  (0, import_react.useEffect)(() => {
+    let mounted = true;
+    const unsub = query.subscribe((docs) => {
+      if (!mounted) return;
+      setDocMap((prev) => {
+        const next = new Map(prev);
+        const newIds = /* @__PURE__ */ new Set();
+        for (const doc of docs) {
+          const id = doc.id;
+          newIds.add(id);
+          const existing = prev.get(id);
+          if (!existing || !shallowEqual(existing, doc)) next.set(id, { ...doc });
+        }
+        for (const id of prev.keys()) {
+          if (!newIds.has(id)) next.delete(id);
+        }
+        if (next.size === prev.size) {
+          let same = true;
+          for (const [id, d] of next) {
+            if (prev.get(id) !== d) {
+              same = false;
+              break;
+            }
+          }
+          if (same) return prev;
+        }
+        return next;
+      });
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, []);
+  return docMap;
+}
+
+// src/index.ts
+var import_meridian_shared2 = require("meridian-shared");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRNClient,
+  defineSchema,
+  useDoc,
+  useLiveQuery,
+  useMutation,
+  usePresence,
+  useQuery,
+  useQueryOptimized,
+  useSync,
+  z
+});

package/dist/index.js

@@ -0,0 +1,390 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/rn-client.ts
+import { HLC, generateNodeId } from "meridian-shared";
+var AsyncKVStore = class {
+  memoryFallback = /* @__PURE__ */ new Map();
+  async get(key) {
+    try {
+      const AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+      return await AsyncStorage.getItem(`meridian:${key}`);
+    } catch {
+      return this.memoryFallback.get(key) ?? null;
+    }
+  }
+  async set(key, value) {
+    try {
+      const AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+      await AsyncStorage.setItem(`meridian:${key}`, value);
+    } catch {
+      this.memoryFallback.set(key, value);
+    }
+  }
+  async delete(key) {
+    try {
+      const AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+      await AsyncStorage.removeItem(`meridian:${key}`);
+    } catch {
+      this.memoryFallback.delete(key);
+    }
+  }
+  async keys() {
+    try {
+      const AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+      const allKeys = await AsyncStorage.getAllKeys();
+      return allKeys.filter((k) => k.startsWith("meridian:")).map((k) => k.replace("meridian:", ""));
+    } catch {
+      return Array.from(this.memoryFallback.keys());
+    }
+  }
+};
+function createRNClient(config) {
+  const { schema, serverUrl, auth, debug = false } = config;
+  const nodeId = generateNodeId();
+  const clock = new HLC(nodeId);
+  const store = new AsyncKVStore();
+  const collections = {};
+  let ws = null;
+  let state = "disconnected";
+  let destroyed = false;
+  for (const name of Object.keys(schema.collections)) {
+    const proxy = new RNCollectionProxy(name, store, clock, () => ws, serverUrl, auth, debug);
+    collections[name] = proxy;
+  }
+  connect().catch(() => {
+  });
+  async function connect() {
+    if (destroyed) return;
+    state = "connecting";
+    try {
+      ws = new WebSocket(serverUrl);
+      ws.onopen = async () => {
+        state = "connected";
+        if (auth) {
+          const token = await auth.getToken();
+          ws?.send(JSON.stringify({ type: "auth", token }));
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "ack" && msg.opIds) {
+            for (const id of msg.opIds) {
+              store.delete(`pending:${id}`).catch(() => {
+              });
+            }
+          }
+        } catch {
+        }
+      };
+      ws.onerror = () => {
+        state = "error";
+      };
+      ws.onclose = () => {
+        state = "disconnected";
+        if (!destroyed) setTimeout(connect, 3e3);
+      };
+    } catch {
+      state = "disconnected";
+      if (!destroyed) setTimeout(connect, 5e3);
+    }
+  }
+  const client = {
+    get connectionState() {
+      return state;
+    },
+    async sync() {
+      if (ws && state === "connected") {
+        const pendingKeys = await store.keys();
+        const ops = [];
+        for (const key of pendingKeys) {
+          if (key.startsWith("pending:")) {
+            const opJson = await store.get(key);
+            if (opJson) ops.push(JSON.parse(opJson));
+          }
+        }
+        if (ops.length > 0) {
+          ws.send(JSON.stringify({ type: "push", ops }));
+        }
+      }
+    },
+    destroy() {
+      destroyed = true;
+      if (ws) {
+        ws.onclose = null;
+        ws.close();
+        ws = null;
+      }
+    }
+  };
+  for (const [name, proxy] of Object.entries(collections)) {
+    client[name] = proxy;
+  }
+  return client;
+}
+var RNCollectionProxy = class {
+  collection;
+  store;
+  clock;
+  getWs;
+  serverUrl;
+  auth;
+  debug;
+  constructor(collection, store, clock, getWs, serverUrl, auth, debug) {
+    this.collection = collection;
+    this.store = store;
+    this.clock = clock;
+    this.getWs = getWs;
+    this.serverUrl = serverUrl;
+    this.auth = auth;
+    this.debug = debug;
+  }
+  find(filter) {
+    const self = this;
+    const listeners = /* @__PURE__ */ new Set();
+    return {
+      subscribe(cb) {
+        listeners.add(cb);
+        self.queryDocs(filter).then(cb);
+        return () => {
+          listeners.delete(cb);
+        };
+      },
+      get: () => self.queryDocs(filter)
+    };
+  }
+  findOne(id) {
+    return {
+      subscribe: (cb) => {
+        this.getDoc(id).then(cb);
+        return () => {
+        };
+      },
+      get: () => this.getDoc(id)
+    };
+  }
+  live(options = {}) {
+    return this.find(options.where);
+  }
+  async put(doc) {
+    if (!doc.id) doc.id = `rn-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const hlcTs = this.clock.now();
+    const hlcStr = `${hlcTs.wallTime}-${hlcTs.counter.toString().padStart(4, "0")}-${hlcTs.nodeId}`;
+    await this.store.set(`doc:${this.collection}:${doc.id}`, JSON.stringify(doc));
+    await this.queueOp(doc.id, Object.keys(doc).filter((k) => k !== "id"), doc, hlcStr);
+    this.trySync();
+  }
+  async update(id, fields) {
+    const existing = await this.getDoc(id);
+    if (!existing) return;
+    const merged = { ...existing, ...fields };
+    await this.store.set(`doc:${this.collection}:${id}`, JSON.stringify(merged));
+    const hlcTs = this.clock.now();
+    const hlcStr = `${hlcTs.wallTime}-${hlcTs.counter.toString().padStart(4, "0")}-${hlcTs.nodeId}`;
+    await this.queueOp(id, Object.keys(fields), fields, hlcStr);
+    this.trySync();
+  }
+  async delete(id) {
+    await this.store.set(`doc:${this.collection}:${id}:deleted`, "true");
+    this.trySync();
+  }
+  async queryDocs(filter) {
+    const allKeys = await this.store.keys();
+    const docs = [];
+    for (const key of allKeys) {
+      if (!key.startsWith(`doc:${this.collection}:`)) continue;
+      const id = key.split(":").pop();
+      const deleted = await this.store.get(`doc:${this.collection}:${id}:deleted`);
+      if (deleted === "true") continue;
+      const raw = await this.store.get(key);
+      if (!raw) continue;
+      const doc = JSON.parse(raw);
+      if (filter) {
+        let matches = true;
+        for (const [k, v] of Object.entries(filter)) {
+          if (doc[k] !== v) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      docs.push(doc);
+    }
+    return docs;
+  }
+  async getDoc(id) {
+    const raw = await this.store.get(`doc:${this.collection}:${id}`);
+    if (!raw) return null;
+    return JSON.parse(raw);
+  }
+  async queueOp(docId, fields, values, hlc) {
+    for (const field of fields) {
+      const op = {
+        id: `${docId}-${field}-${hlc}`,
+        collection: this.collection,
+        docId,
+        field,
+        value: values[field],
+        hlc,
+        nodeId: this.clock.peek().nodeId
+      };
+      await this.store.set(`pending:${op.id}`, JSON.stringify(op));
+    }
+  }
+  trySync() {
+    const ws = this.getWs();
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    this.store.keys().then(async (keys) => {
+      const ops = [];
+      for (const key of keys) {
+        if (key.startsWith("pending:")) {
+          const raw = await this.store.get(key);
+          if (raw) ops.push(JSON.parse(raw));
+        }
+      }
+      if (ops.length > 0) {
+        ws.send(JSON.stringify({ type: "push", ops }));
+      }
+    });
+  }
+};
+
+// src/hooks.ts
+import { useState, useEffect, useCallback } from "react";
+function useQuery(query) {
+  const [data, setData] = useState();
+  useEffect(() => {
+    let mounted = true;
+    const unsub = query.subscribe((result) => {
+      if (mounted) setData(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, []);
+  return data;
+}
+function useLiveQuery(collection, options = {}) {
+  const [data, setData] = useState();
+  const { where: _w, orderBy: _ob, limit: _lim } = options;
+  const depKey = `${_ob || ""}-${_lim || 0}-${Object.entries(_w || {}).sort().join(",")}`;
+  useEffect(() => {
+    const query = collection.live(options);
+    let mounted = true;
+    const unsub = query.subscribe((result) => {
+      if (mounted) setData(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, [depKey]);
+  return data;
+}
+function useDoc(collection, docId) {
+  const [doc, setDoc] = useState();
+  useEffect(() => {
+    if (!docId) {
+      setDoc(null);
+      return;
+    }
+    let mounted = true;
+    const unsub = collection.findOne(docId).subscribe((result) => {
+      if (mounted) setDoc(result);
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, [docId]);
+  return doc;
+}
+function useSync(client) {
+  const [state, setState] = useState({ connected: false, pendingCount: 0 });
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setState({ connected: client.connectionState === "connected", pendingCount: 0 });
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  return state;
+}
+function usePresence(_client) {
+  return {};
+}
+function useMutation(collection) {
+  return {
+    put: useCallback((doc) => collection.put(doc), []),
+    update: useCallback((id, fields) => collection.update(id, fields), []),
+    remove: useCallback((id) => collection.delete(id), [])
+  };
+}
+function shallowEqual(a, b) {
+  const ka = Object.keys(a), kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (const k of ka) if (a[k] !== b[k]) return false;
+  return true;
+}
+function useQueryOptimized(query) {
+  const [docMap, setDocMap] = useState(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    let mounted = true;
+    const unsub = query.subscribe((docs) => {
+      if (!mounted) return;
+      setDocMap((prev) => {
+        const next = new Map(prev);
+        const newIds = /* @__PURE__ */ new Set();
+        for (const doc of docs) {
+          const id = doc.id;
+          newIds.add(id);
+          const existing = prev.get(id);
+          if (!existing || !shallowEqual(existing, doc)) next.set(id, { ...doc });
+        }
+        for (const id of prev.keys()) {
+          if (!newIds.has(id)) next.delete(id);
+        }
+        if (next.size === prev.size) {
+          let same = true;
+          for (const [id, d] of next) {
+            if (prev.get(id) !== d) {
+              same = false;
+              break;
+            }
+          }
+          if (same) return prev;
+        }
+        return next;
+      });
+    });
+    return () => {
+      unsub();
+      mounted = false;
+    };
+  }, []);
+  return docMap;
+}
+
+// src/index.ts
+import {
+  defineSchema,
+  z
+} from "meridian-shared";
+export {
+  createRNClient,
+  defineSchema,
+  useDoc,
+  useLiveQuery,
+  useMutation,
+  usePresence,
+  useQuery,
+  useQueryOptimized,
+  useSync,
+  z
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "meridian-react-native",
+  "version": "0.4.0",
+  "description": "React Native client for Meridian — local-first sync with SQLite/AsyncStorage",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --external react --external react-native",
+    "test": "vitest run --passWithNoTests",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --external react --external react-native"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-native": "^0.72.0"
+  },
+  "dependencies": {
+    "meridian-client": "workspace:*",
+    "meridian-shared": "workspace:*",
+    "@react-native-async-storage/async-storage": "^1.21.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0",
+    "react-native": "^0.76.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "files": ["dist"],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vahapogut/MeridianDB"
+  },
+  "keywords": ["react-native", "meridian", "sync", "local-first", "offline-first", "crdt", "mobile"],
+  "author": "Abdulvahap OGUT <info@ipeclabs.com>"
+}