@xnetjs/sqlite 0.0.2 → 0.1.0

package/dist/chunk-CBU263LI.js

@@ -0,0 +1,30 @@
+// src/errors.ts
+var SQLITE_CORRUPT_RESULT_CODE = 11;
+var SQLITE_NOTADB_RESULT_CODE = 26;
+function toErrorLike(error) {
+  if (!error || typeof error !== "object") {
+    return null;
+  }
+  return error;
+}
+function isSQLiteCorruptionError(error) {
+  return isSQLiteCorruptionErrorInternal(error, /* @__PURE__ */ new Set());
+}
+function isSQLiteCorruptionErrorInternal(error, seen) {
+  const current = toErrorLike(error);
+  if (!current) {
+    return false;
+  }
+  if (seen.has(error)) {
+    return false;
+  }
+  seen.add(error);
+  const message = typeof current.message === "string" ? current.message.toLowerCase() : String(current.message);
+  const code = typeof current.code === "string" ? current.code.toUpperCase() : "";
+  const resultCode = typeof current.resultCode === "number" ? current.resultCode : null;
+  return resultCode === SQLITE_CORRUPT_RESULT_CODE || resultCode === SQLITE_NOTADB_RESULT_CODE || code === "SQLITE_CORRUPT" || code === "SQLITE_NOTADB" || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb") || message.includes("database disk image is malformed") || message.includes("file is not a database") || isSQLiteCorruptionErrorInternal(current.cause, seen);
+}
+
+export {
+  isSQLiteCorruptionError
+};

package/dist/chunk-CGI2YBZY.js

@@ -0,0 +1,16 @@
+// src/adapters/boot-log-bridge.ts
+var BOOT_LOG_KEY = "__xnetSqliteBootLog";
+function bootLogMessage(args) {
+  return { [BOOT_LOG_KEY]: args };
+}
+function readBootLogArgs(data) {
+  if (typeof data === "object" && data !== null && Array.isArray(data[BOOT_LOG_KEY])) {
+    return data[BOOT_LOG_KEY];
+  }
+  return null;
+}
+
+export {
+  bootLogMessage,
+  readBootLogArgs
+};

package/dist/chunk-S6MT6KCI.js

@@ -0,0 +1,279 @@
+// src/browser-support.ts
+function withTimeout(promise, timeoutMs, errorMessage) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs))
+  ]);
+}
+function isSafariPrivateBrowsing() {
+  const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  if (!isSafari) return false;
+  try {
+    localStorage.setItem("_test", "1");
+    localStorage.removeItem("_test");
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function checkBrowserSupport() {
+  const result = {
+    opfs: false,
+    worker: true,
+    supported: false
+  };
+  if (typeof Worker === "undefined") {
+    result.worker = false;
+    result.reason = "Web Workers not supported in this browser.";
+    return result;
+  }
+  if (typeof navigator === "undefined" || !navigator.storage?.getDirectory) {
+    result.reason = "Origin Private File System (OPFS) not supported. Please use a modern browser (Chrome 102+, Firefox 111+, Safari 16.4+).";
+    return result;
+  }
+  try {
+    const testOPFS = async () => {
+      await navigator.storage.getDirectory();
+    };
+    await withTimeout(testOPFS(), 5e3, "OPFS access timeout");
+    result.opfs = true;
+    result.supported = true;
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    const normalized = errorMessage.toLowerCase();
+    const safariStorageContextError = normalized.includes("object can not be found here") || normalized.includes("object cannot be found here") || normalized.includes("operation is insecure");
+    if (isSafariPrivateBrowsing()) {
+      result.warning = "Safari Private Browsing detected. Storage may be limited. For full functionality, switch to normal mode or use the xNet Desktop App.";
+      result.supported = true;
+    } else if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent) && safariStorageContextError) {
+      result.warning = "Safari storage APIs are restricted in this context. xNet will continue, but persistence may be limited between sessions.";
+      result.supported = true;
+    } else {
+      result.warning = `Storage access limited (${errorMessage}). Data persistence may be limited between sessions. For full functionality, use the xNet Desktop App.`;
+      result.supported = true;
+    }
+  }
+  return result;
+}
+async function readStorageEstimate() {
+  const estimate = await navigator.storage.estimate?.().catch(() => void 0);
+  return {
+    usageBytes: estimate?.usage,
+    quotaBytes: estimate?.quota
+  };
+}
+function getPersistenceMessage(input) {
+  const { persisted, requested, granted } = input;
+  if (persisted) {
+    return "Durable local storage is enabled. This browser agreed to keep your xNet workspace unless you explicitly clear site data.";
+  }
+  if (!requested) {
+    return "Durable storage is not enabled yet. xNet can request stronger local-storage protection when you choose to enable it.";
+  }
+  if (granted === false) {
+    return "This browser declined durable storage for now. xNet keeps working, and browsers re-evaluate the request as install, notification, and usage signals change.";
+  }
+  return "This browser did not confirm durable storage. xNet will keep working, but local data may be evicted under storage pressure or aggressive cleanup.";
+}
+async function checkPersistentStorage() {
+  return requestPersistentStorage({ request: false });
+}
+function isSilentPersistRequestSafe() {
+  if (typeof navigator === "undefined") return false;
+  return !/Firefox|FxiOS/i.test(navigator.userAgent);
+}
+function watchPersistentStoragePermission(onChange) {
+  let active = true;
+  let detach = null;
+  void (async () => {
+    try {
+      const status = await navigator.permissions.query({
+        name: "persistent-storage"
+      });
+      if (!active) return;
+      const listener = () => onChange(status.state);
+      status.addEventListener("change", listener);
+      detach = () => status.removeEventListener("change", listener);
+    } catch {
+    }
+  })();
+  return () => {
+    active = false;
+    detach?.();
+    detach = null;
+  };
+}
+async function requestPersistentStorage(options = { request: true }) {
+  const requested = options.request ?? true;
+  if (typeof navigator === "undefined" || !navigator.storage) {
+    return {
+      supported: false,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: false,
+      state: "unsupported",
+      message: "This browser does not expose storage persistence APIs. Local data can still work, but the browser may evict it under storage pressure."
+    };
+  }
+  const estimate = await readStorageEstimate();
+  if (!navigator.storage.persist || !navigator.storage.persisted) {
+    return {
+      supported: false,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: false,
+      state: "unsupported",
+      message: "This browser cannot explicitly request durable storage. Local data can still work, but the browser may evict it under storage pressure.",
+      ...estimate
+    };
+  }
+  try {
+    const alreadyPersisted = await navigator.storage.persisted();
+    const granted = alreadyPersisted ? true : requested ? await navigator.storage.persist() : null;
+    const persisted = granted ? true : await navigator.storage.persisted();
+    if (persisted) {
+      return {
+        supported: true,
+        persisted,
+        granted,
+        requested,
+        requestable: false,
+        state: "granted",
+        message: getPersistenceMessage({ persisted, requested, granted }),
+        ...estimate
+      };
+    }
+    return {
+      supported: true,
+      persisted,
+      granted,
+      requested,
+      requestable: true,
+      state: "not-granted",
+      message: getPersistenceMessage({ persisted, requested, granted }),
+      ...estimate
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      supported: true,
+      persisted: null,
+      granted: null,
+      requested,
+      requestable: true,
+      state: "error",
+      message: `xNet could not confirm durable storage (${reason}). Local data may still work, but persistence guarantees are unclear.`,
+      ...estimate
+    };
+  }
+}
+function showUnsupportedBrowserMessage(reason) {
+  const container = document.getElementById("app") ?? document.body;
+  container.innerHTML = `
+    <div style="
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 2rem;
+      text-align: center;
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #fafafa;
+      color: #333;
+    ">
+      <div style="
+        background: white;
+        padding: 2rem 2.5rem;
+        border-radius: 12px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+        max-width: 480px;
+        width: 100%;
+      ">
+        <h1 style="
+          font-size: 1.5rem;
+          margin: 0 0 1rem 0;
+          color: #111;
+          font-weight: 600;
+        ">
+          Browser Not Supported
+        </h1>
+        <p style="
+          color: #555;
+          margin: 0 0 1.5rem 0;
+          line-height: 1.6;
+          font-size: 1rem;
+        ">
+          ${escapeHtml(reason)}
+        </p>
+        <div style="
+          background: #f5f5f5;
+          padding: 1rem;
+          border-radius: 8px;
+          text-align: left;
+          font-size: 0.9rem;
+        ">
+          <p style="margin: 0 0 0.5rem 0; font-weight: 500;">Supported browsers:</p>
+          <ul style="margin: 0; padding-left: 1.5rem; color: #666;">
+            <li>Chrome 102+ (March 2022)</li>
+            <li>Edge 102+ (March 2022)</li>
+            <li>Firefox 111+ (March 2023)</li>
+            <li>Safari 16.4+ (March 2023)</li>
+          </ul>
+        </div>
+        <p style="
+          color: #888;
+          font-size: 0.875rem;
+          margin: 1.5rem 0 0 0;
+        ">
+          For the best experience, please use the 
+          <a href="https://xnet.app/download" style="
+            color: #0066cc;
+            text-decoration: none;
+            font-weight: 500;
+          ">
+            xNet Desktop App
+          </a>
+          or update your browser.
+        </p>
+      </div>
+    </div>
+  `;
+}
+function escapeHtml(text) {
+  const div = document.createElement("div");
+  div.textContent = text;
+  return div.innerHTML;
+}
+var MEMORY_FALLBACK_COUNT_KEY = "xnet:sqlite:memory-fallback-count";
+function recordMemoryFallbackSession() {
+  try {
+    const count = getMemoryFallbackSessionCount() + 1;
+    localStorage.setItem(MEMORY_FALLBACK_COUNT_KEY, String(count));
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function getMemoryFallbackSessionCount() {
+  try {
+    const raw = localStorage.getItem(MEMORY_FALLBACK_COUNT_KEY);
+    const parsed = raw === null ? 0 : Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export {
+  checkBrowserSupport,
+  checkPersistentStorage,
+  isSilentPersistRequestSafe,
+  watchPersistentStoragePermission,
+  requestPersistentStorage,
+  showUnsupportedBrowserMessage,
+  recordMemoryFallbackSession,
+  getMemoryFallbackSessionCount
+};

package/dist/chunk-SV475UL5.js

@@ -0,0 +1,44 @@
+// src/adapters/opfs-capability.ts
+function resolveScope(scope) {
+  if (scope) return scope;
+  const g = globalThis;
+  return g;
+}
+function supportsOpfs(scope) {
+  return typeof resolveScope(scope).navigator?.storage?.getDirectory === "function";
+}
+function supportsSyncAccessHandle(scope) {
+  const s = resolveScope(scope);
+  if (typeof s.FileSystemSyncAccessHandle !== "undefined") return true;
+  const proto = s.FileSystemFileHandle?.prototype;
+  return Boolean(proto && "createSyncAccessHandle" in proto);
+}
+function isCrossOriginIsolated(scope) {
+  const s = resolveScope(scope);
+  return typeof s.SharedArrayBuffer !== "undefined" && s.crossOriginIsolated === true;
+}
+function detectOpfsCapability(scope) {
+  const opfs = supportsOpfs(scope);
+  const syncAccessHandle = supportsSyncAccessHandle(scope);
+  const crossOriginIsolated = isCrossOriginIsolated(scope);
+  let mode;
+  let reason;
+  if (!opfs) {
+    mode = "memory";
+    reason = "OPFS is unavailable in this context (private browsing or an unsupported engine); local data will not persist across reloads.";
+  } else if (syncAccessHandle) {
+    mode = "sync-access-handle";
+    reason = "OPFS sync access handles available \u2014 using the durable opfs-sahpool fast path.";
+  } else {
+    mode = "async-opfs";
+    reason = "OPFS is available but sync access handles are not (iOS 15.2\u201316.3 or an older WebView); falling back to the slower async OPFS backend. Data still persists.";
+  }
+  return { opfs, syncAccessHandle, crossOriginIsolated, mode, reason };
+}
+
+export {
+  supportsOpfs,
+  supportsSyncAccessHandle,
+  isCrossOriginIsolated,
+  detectOpfsCapability
+};