@nbt-dev/components 0.0.5

package/dist/chunk-3ZM6YOA4.js

@@ -0,0 +1,704 @@
+"use client";
+
+// src/core/config.tsx
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+var DevToolsConfigContext = React.createContext({
+  apiBaseUrl: ""
+});
+var DevToolsConfigProvider = ({ apiBaseUrl = "", children }) => {
+  const value = React.useMemo(() => ({ apiBaseUrl }), [apiBaseUrl]);
+  return /* @__PURE__ */ jsx(DevToolsConfigContext.Provider, { value, children });
+};
+function useDevToolsConfig() {
+  return React.useContext(DevToolsConfigContext);
+}
+function wsBaseFrom(apiBaseUrl) {
+  if (!apiBaseUrl) {
+    const loc = window.location;
+    const proto = loc.protocol === "https:" ? "wss:" : "ws:";
+    return `${proto}//${loc.host}`;
+  }
+  return apiBaseUrl.replace(/^http(s?):/, "ws$1:");
+}
+
+// src/core/auth.ts
+var TOKEN_KEY = "nbt_devtools_token";
+function getDevToolsToken() {
+  try {
+    return localStorage.getItem(TOKEN_KEY);
+  } catch {
+    return null;
+  }
+}
+function setDevToolsToken(token) {
+  try {
+    localStorage.setItem(TOKEN_KEY, token);
+  } catch {
+  }
+}
+function clearDevToolsToken() {
+  try {
+    localStorage.removeItem(TOKEN_KEY);
+  } catch {
+  }
+}
+function authHeaders(base) {
+  const h = { ...base ?? {} };
+  const t = getDevToolsToken();
+  if (t) h["Authorization"] = `Bearer ${t}`;
+  return h;
+}
+async function fetchWhoAmI(apiBaseUrl, signal) {
+  const r = await fetch(`${apiBaseUrl}/_console/whoami`, {
+    signal,
+    credentials: "include",
+    headers: authHeaders()
+  });
+  if (!r.ok) throw new Error(`HTTP ${r.status}`);
+  return await r.json();
+}
+async function devToolsSignIn(apiBaseUrl, email, password) {
+  const r = await fetch(`${apiBaseUrl}/api/auth/user/signin`, {
+    method: "POST",
+    credentials: "include",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email, password })
+  });
+  if (!r.ok) {
+    throw new Error(r.status === 401 ? "Invalid email or password" : `Sign-in failed (HTTP ${r.status})`);
+  }
+  const j = await r.json();
+  if (!j.token) throw new Error("Sign-in returned no token");
+  setDevToolsToken(j.token);
+}
+function devToolsSignOut() {
+  clearDevToolsToken();
+}
+function base64UrlEncode(value) {
+  if (typeof btoa === "function") {
+    return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  }
+  throw new Error("No base64 encoder available for WS auth");
+}
+function wsAuthProtocols(name) {
+  const t = getDevToolsToken();
+  return t ? [name, `auth-${base64UrlEncode(t)}`] : [name];
+}
+
+// src/core/use-bulk-stream.ts
+import React2, {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+
+// src/generated/bulk-protocol.ts
+var FRAME_SCHEMA = 1;
+var FRAME_DATA = 2;
+var FRAME_DATA_END = 3;
+var FRAME_DELTA_INS = 4;
+var FRAME_DELTA_UPD = 5;
+var FRAME_DELTA_DEL = 6;
+var FRAME_ERROR = 255;
+var TYPE_U8 = 1;
+var TYPE_U16 = 2;
+var TYPE_U32 = 3;
+var TYPE_U64 = 4;
+var TYPE_S8 = 5;
+var TYPE_S16 = 6;
+var TYPE_S32 = 7;
+var TYPE_S64 = 8;
+var TYPE_BOOL = 9;
+var TYPE_FLOAT32 = 10;
+var TYPE_FLOAT64 = 11;
+var TYPE_STRING = 12;
+var TYPE_DATETIME = 13;
+var TYPE_DOCUMENT = 14;
+function fixedSizeForType(type) {
+  switch (type) {
+    case TYPE_U8:
+      return 1;
+    case TYPE_U16:
+      return 2;
+    case TYPE_U32:
+      return 4;
+    case TYPE_U64:
+      return 8;
+    case TYPE_S8:
+      return 1;
+    case TYPE_S16:
+      return 2;
+    case TYPE_S32:
+      return 4;
+    case TYPE_S64:
+      return 8;
+    case TYPE_BOOL:
+      return 1;
+    case TYPE_FLOAT32:
+      return 4;
+    case TYPE_FLOAT64:
+      return 8;
+    case TYPE_STRING:
+      return 0;
+    case TYPE_DATETIME:
+      return 8;
+    case TYPE_DOCUMENT:
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+// src/core/data-store.ts
+var BulkDataStore = class {
+  constructor() {
+    this.columns = [];
+    this.rows = [];
+    this.totalRows = 0;
+    this.searchActive = false;
+    this._fullRows = [];
+    this._fullTotalRows = 0;
+    this._idColIndex = -1;
+    this._query = "";
+  }
+  applySchema(schema) {
+    this.columns = schema.columns;
+    this.totalRows = schema.totalRows;
+    this.rows = [];
+    this._fullRows = [];
+    this._fullTotalRows = schema.totalRows;
+    this.searchActive = false;
+    this._query = "";
+    this._idColIndex = schema.columns.findIndex((c) => c.name === "id");
+  }
+  appendChunk(chunk) {
+    for (let i = 0; i < chunk.length; i++) {
+      const row = chunk[i];
+      this._fullRows.push(row);
+      if (!this.searchActive) this.rows.push(row);
+    }
+  }
+  applyDelta(delta) {
+    const target = this._fullRows;
+    if (delta.op === FRAME_DELTA_INS && delta.rowData) {
+      target.push(delta.rowData);
+      this._fullTotalRows++;
+      this.totalRows++;
+      if (!this.searchActive) this.rows = this._fullRows;
+      else this._applySearch();
+      return;
+    }
+    if (delta.op === FRAME_DELTA_UPD && delta.rowData) {
+      const idx = this._findRowById(target, delta.rowData);
+      if (idx >= 0) target[idx] = delta.rowData;
+      if (this.searchActive) this._applySearch();
+      return;
+    }
+    if (delta.op === FRAME_DELTA_DEL && delta.id !== void 0) {
+      const idStr = String(delta.id);
+      const idx = this._findRowByIdStr(target, idStr);
+      if (idx >= 0) {
+        target.splice(idx, 1);
+        this._fullTotalRows--;
+        this.totalRows--;
+        if (!this.searchActive) this.rows = this._fullRows;
+        else this._applySearch();
+      }
+      return;
+    }
+  }
+  search(query) {
+    const q = query.trim().toLowerCase();
+    if (!q) {
+      this.exitSearch();
+      return;
+    }
+    this.searchActive = true;
+    this._query = q;
+    this._applySearch();
+  }
+  exitSearch() {
+    if (!this.searchActive) return;
+    this.rows = this._fullRows;
+    this.totalRows = this._fullTotalRows;
+    this.searchActive = false;
+    this._query = "";
+  }
+  getRowCount() {
+    return this.rows.length;
+  }
+  _findRowById(rows, rowData) {
+    if (this._idColIndex < 0) return -1;
+    const id = rowData[this._idColIndex];
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i][this._idColIndex] === id) return i;
+    }
+    return -1;
+  }
+  _findRowByIdStr(rows, idStr) {
+    if (this._idColIndex < 0) return -1;
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i][this._idColIndex] === idStr) return i;
+    }
+    return -1;
+  }
+  _applySearch() {
+    this.rows = this._fullRows.filter(
+      (row) => row.some((value) => value.toLowerCase().includes(this._query))
+    );
+    this.totalRows = this.rows.length;
+  }
+};
+
+// src/core/bulk-decoder.ts
+var textDecoder = new TextDecoder();
+var SID_BYTES = 2;
+var HEAD = 1 + SID_BYTES;
+function epochToDate(epoch) {
+  const abs = Math.abs(epoch);
+  if (abs < 1e10) return new Date(epoch * 1e3);
+  if (abs < 1e13) return new Date(epoch);
+  if (abs < 1e16) return new Date(epoch / 1e3);
+  return new Date(epoch / 1e6);
+}
+function formatCellValue(view, offset, col) {
+  switch (col.type) {
+    case TYPE_U8:
+      return [String(view.getUint8(offset)), 1];
+    case TYPE_S8:
+      return [String(view.getInt8(offset)), 1];
+    case TYPE_BOOL:
+      return [view.getUint8(offset) ? "true" : "false", 1];
+    case TYPE_U16:
+      return [String(view.getUint16(offset, true)), 2];
+    case TYPE_S16:
+      return [String(view.getInt16(offset, true)), 2];
+    case TYPE_U32:
+      return [String(view.getUint32(offset, true)), 4];
+    case TYPE_S32:
+      return [String(view.getInt32(offset, true)), 4];
+    case TYPE_FLOAT32:
+      return [String(view.getFloat32(offset, true)), 4];
+    case TYPE_U64:
+      return [String(view.getBigUint64(offset, true)), 8];
+    case TYPE_S64:
+      return [String(view.getBigInt64(offset, true)), 8];
+    case TYPE_FLOAT64:
+      return [String(view.getFloat64(offset, true)), 8];
+    case TYPE_DATETIME: {
+      const epoch = Number(view.getBigInt64(offset, true));
+      if (epoch === 0) return ["", 8];
+      return [epochToDate(epoch).toISOString(), 8];
+    }
+    case TYPE_STRING:
+    case TYPE_DOCUMENT: {
+      const len = view.getUint32(offset, true);
+      const bytes = new Uint8Array(view.buffer, view.byteOffset + offset + 4, len);
+      return [textDecoder.decode(bytes), 4 + len];
+    }
+    default:
+      return ["", 0];
+  }
+}
+function getFrameType(buf) {
+  return new DataView(buf).getUint8(0);
+}
+function getFrameSid(buf) {
+  return new DataView(buf).getUint16(1, true);
+}
+function parseSchema(buf) {
+  const view = new DataView(buf);
+  let offset = 0;
+  const frameType = view.getUint8(offset);
+  offset += 1;
+  if (frameType !== FRAME_SCHEMA) {
+    throw new Error(`Expected SCHEMA frame (0x01), got 0x${frameType.toString(16)}`);
+  }
+  offset += SID_BYTES;
+  const totalRows = view.getUint32(offset, true);
+  offset += 4;
+  const columnCount = view.getUint16(offset, true);
+  offset += 2;
+  const columns = [];
+  for (let i = 0; i < columnCount; i++) {
+    const type = view.getUint8(offset);
+    offset += 1;
+    const nameLen = view.getUint16(offset, true);
+    offset += 2;
+    const nameBytes = new Uint8Array(buf, offset, nameLen);
+    const name = textDecoder.decode(nameBytes);
+    offset += nameLen;
+    columns.push({ name, type, fixedSize: fixedSizeForType(type) });
+  }
+  return { totalRows, columns };
+}
+function parseDataChunk(buf, columns) {
+  const view = new DataView(buf);
+  let offset = 0;
+  const frameType = view.getUint8(offset);
+  offset += 1;
+  if (frameType !== FRAME_DATA) {
+    throw new Error(`Expected DATA frame, got 0x${frameType.toString(16)}`);
+  }
+  offset += SID_BYTES;
+  const rowCount = view.getUint16(offset, true);
+  offset += 2;
+  const rows = [];
+  for (let r = 0; r < rowCount; r++) {
+    const row = [];
+    for (let c = 0; c < columns.length; c++) {
+      const [value, bytesRead] = formatCellValue(view, offset, columns[c]);
+      row.push(value);
+      offset += bytesRead;
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function parseDelta(buf, columns) {
+  const view = new DataView(buf);
+  let offset = 0;
+  const op = view.getUint8(offset);
+  offset += 1;
+  offset += SID_BYTES;
+  if (op === FRAME_DELTA_DEL) {
+    const len = view.getUint16(offset, true);
+    offset += 2;
+    const bytes = new Uint8Array(buf, offset, len);
+    return { op, id: textDecoder.decode(bytes) };
+  }
+  if (op === FRAME_DELTA_INS || op === FRAME_DELTA_UPD) {
+    const rowData = [];
+    for (let c = 0; c < columns.length; c++) {
+      const [value, bytesRead] = formatCellValue(view, offset, columns[c]);
+      rowData.push(value);
+      offset += bytesRead;
+    }
+    return { op, rowData };
+  }
+  throw new Error(`Unknown delta op 0x${op.toString(16)}`);
+}
+function parseError(buf) {
+  const view = new DataView(buf);
+  const len = view.getUint16(HEAD, true);
+  const bytes = new Uint8Array(buf, HEAD + 2, len);
+  return textDecoder.decode(bytes);
+}
+function encodeStreamCmd(sid, cart, entity, opts) {
+  return JSON.stringify({ cmd: "sub", sid, cart, entity, ...opts });
+}
+
+// src/core/use-bulk-stream.ts
+var BulkStreamContext = createContext(null);
+function base64UrlEncode2(value) {
+  if (typeof btoa === "function") {
+    return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  }
+  throw new Error("No base64 encoder available for bulk WS auth");
+}
+function bulkAuthProtocols(token) {
+  return ["nimbit-bulk", `auth-${base64UrlEncode2(token)}`];
+}
+var _wsTokenCache = null;
+var WS_TOKEN_TTL_MS = 6e4;
+async function fetchWsToken(signal, apiBaseUrl) {
+  const own = getDevToolsToken();
+  if (own) return own;
+  const now = Date.now();
+  if (_wsTokenCache?.apiBaseUrl === apiBaseUrl && now - _wsTokenCache.at < WS_TOKEN_TTL_MS) {
+    return _wsTokenCache.token;
+  }
+  const r = await fetch(`${apiBaseUrl}/api/auth/session/current`, {
+    method: "POST",
+    signal,
+    credentials: "include",
+    headers: { "content-type": "application/json" }
+  });
+  if (!r.ok) return null;
+  const j = await r.json();
+  const token = j.session?.token;
+  if (!token) return null;
+  _wsTokenCache = { apiBaseUrl, token, at: now };
+  return token;
+}
+function invalidateWsToken() {
+  _wsTokenCache = null;
+}
+function notify(view) {
+  view.listeners.forEach((cb) => cb());
+}
+function BulkStreamProvider({ registry, children }) {
+  const { apiBaseUrl } = useDevToolsConfig();
+  const wsRef = useRef(null);
+  const sendQueueRef = useRef([]);
+  const sidCounterRef = useRef(1);
+  const viewsBySidRef = useRef(/* @__PURE__ */ new Map());
+  const viewsByKeyRef = useRef(/* @__PURE__ */ new Map());
+  const preloadedRef = useRef(false);
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState(null);
+  const sendCmd = (cmd) => {
+    const ws = wsRef.current;
+    if (ws && ws.readyState === WebSocket.OPEN) ws.send(cmd);
+    else sendQueueRef.current.push(cmd);
+  };
+  const flushQueue = () => {
+    const ws = wsRef.current;
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    const q = sendQueueRef.current;
+    sendQueueRef.current = [];
+    for (const cmd of q) ws.send(cmd);
+  };
+  const getView = (cart, entity) => {
+    const entLower = entity.toLowerCase();
+    const key = `${cart}/${entLower}`;
+    const existing = viewsByKeyRef.current.get(key);
+    if (existing) return existing;
+    const sid = sidCounterRef.current++;
+    const view = {
+      sid,
+      cart,
+      entity: entLower,
+      store: new BulkDataStore(),
+      columns: [],
+      totalRows: 0,
+      loadedRows: 0,
+      streaming: false,
+      error: null,
+      streamRequested: false,
+      onRender: null,
+      listeners: /* @__PURE__ */ new Set()
+    };
+    viewsByKeyRef.current.set(key, view);
+    viewsBySidRef.current.set(sid, view);
+    return view;
+  };
+  const ensureStreamed = (view) => {
+    if (view.streamRequested) return;
+    view.streamRequested = true;
+    sendCmd(encodeStreamCmd(view.sid, view.cart, view.entity));
+  };
+  const handleMessage = (ev) => {
+    const buf = ev.data;
+    const sid = getFrameSid(buf);
+    const view = viewsBySidRef.current.get(sid);
+    if (!view) return;
+    const ft = getFrameType(buf);
+    const store = view.store;
+    switch (ft) {
+      case FRAME_SCHEMA: {
+        const schema = parseSchema(buf);
+        store.applySchema(schema);
+        view.columns = schema.columns;
+        view.totalRows = schema.totalRows;
+        view.loadedRows = 0;
+        view.streaming = true;
+        notify(view);
+        break;
+      }
+      case FRAME_DATA: {
+        const rows = parseDataChunk(buf, store.columns);
+        store.appendChunk(rows);
+        view.loadedRows = store.getRowCount();
+        view.onRender?.();
+        break;
+      }
+      case FRAME_DATA_END:
+        view.streaming = false;
+        notify(view);
+        break;
+      case FRAME_DELTA_INS:
+      case FRAME_DELTA_UPD:
+      case FRAME_DELTA_DEL: {
+        const delta = parseDelta(buf, store.columns);
+        store.applyDelta(delta);
+        view.totalRows = store.totalRows;
+        view.loadedRows = store.getRowCount();
+        view.onRender?.();
+        notify(view);
+        break;
+      }
+      case FRAME_ERROR:
+        view.error = parseError(buf);
+        view.streaming = false;
+        notify(view);
+        break;
+    }
+  };
+  useEffect(() => {
+    const ac = new AbortController();
+    let cancelled = false;
+    let opened = false;
+    let ws = null;
+    sendQueueRef.current = [];
+    sidCounterRef.current = 1;
+    viewsBySidRef.current.clear();
+    viewsByKeyRef.current.clear();
+    preloadedRef.current = false;
+    setConnected(false);
+    setError(null);
+    (async () => {
+      let token = null;
+      try {
+        token = await fetchWsToken(ac.signal, apiBaseUrl);
+      } catch {
+      }
+      if (cancelled) return;
+      ws = token ? new WebSocket(`${wsBaseFrom(apiBaseUrl)}/_ws/bulk`, bulkAuthProtocols(token)) : new WebSocket(`${wsBaseFrom(apiBaseUrl)}/_ws/bulk`, ["nimbit-bulk"]);
+      ws.binaryType = "arraybuffer";
+      wsRef.current = ws;
+      ws.onopen = () => {
+        if (cancelled || wsRef.current !== ws) return;
+        opened = true;
+        setConnected(true);
+        setError(null);
+        flushQueue();
+      };
+      ws.onmessage = handleMessage;
+      ws.onerror = () => {
+      };
+      ws.onclose = () => {
+        if (cancelled || wsRef.current !== ws) return;
+        setConnected(false);
+        wsRef.current = null;
+        if (!opened) {
+          invalidateWsToken();
+          setError("WebSocket connection closed");
+        }
+      };
+    })();
+    return () => {
+      cancelled = true;
+      ac.abort();
+      if (ws) {
+        ws.onopen = ws.onmessage = ws.onerror = ws.onclose = null;
+        try {
+          ws.close();
+        } catch {
+        }
+        if (wsRef.current === ws) wsRef.current = null;
+      }
+    };
+  }, [apiBaseUrl]);
+  useEffect(() => {
+    if (!connected) return;
+    if (preloadedRef.current) return;
+    const keys = Object.keys(registry);
+    if (keys.length === 0) return;
+    preloadedRef.current = true;
+    for (const cart of keys) {
+      for (const ent of registry[cart] ?? []) {
+        const view = getView(cart, ent.name);
+        ensureStreamed(view);
+      }
+    }
+  }, [connected, registry]);
+  const search = (view, query) => {
+    view.store.search(query);
+    view.totalRows = view.store.totalRows;
+    view.loadedRows = view.store.getRowCount();
+    notify(view);
+    view.onRender?.();
+  };
+  const clearSearch = (view) => {
+    view.store.exitSearch();
+    view.totalRows = view.store.totalRows;
+    view.loadedRows = view.store.getRowCount();
+    notify(view);
+    view.onRender?.();
+  };
+  const subscribe = (view, cb) => {
+    view.listeners.add(cb);
+    return () => {
+      view.listeners.delete(cb);
+    };
+  };
+  const ctx = {
+    getView,
+    ensureStreamed,
+    search,
+    clearSearch,
+    subscribe,
+    connected,
+    error
+  };
+  return React2.createElement(BulkStreamContext.Provider, { value: ctx }, children);
+}
+function useBulkRowCounts(registry) {
+  const ctx = useContext(BulkStreamContext);
+  if (!ctx) throw new Error("useBulkRowCounts must be used within BulkStreamProvider");
+  const [, force] = useState(0);
+  const pairs = [];
+  for (const cart of Object.keys(registry)) {
+    for (const ent of registry[cart] ?? []) {
+      pairs.push({ id: `${cart}:${ent.name}`, view: ctx.getView(cart, ent.name) });
+    }
+  }
+  const key = pairs.map((p) => p.id).join("|");
+  useEffect(() => {
+    const unsubs = pairs.map((p) => ctx.subscribe(p.view, () => force((n) => n + 1)));
+    return () => unsubs.forEach((u) => u());
+  }, [key]);
+  const counts = {};
+  for (const p of pairs) counts[p.id] = p.view.totalRows;
+  return counts;
+}
+function useBulkSubscription(cart, entity) {
+  const ctx = useContext(BulkStreamContext);
+  if (!ctx) throw new Error("useBulkSubscription must be used within BulkStreamProvider");
+  const view = ctx.getView(cart, entity);
+  const [, force] = useState(0);
+  useEffect(() => {
+    const unsub = ctx.subscribe(view, () => force((n) => n + 1));
+    ctx.ensureStreamed(view);
+    return unsub;
+  }, [view]);
+  return {
+    store: view.store,
+    connected: ctx.connected,
+    streaming: view.streaming,
+    error: view.error ?? ctx.error,
+    columns: view.columns,
+    totalRows: view.totalRows,
+    loadedRows: view.loadedRows,
+    search: (q) => ctx.search(view, q),
+    clearSearch: () => ctx.clearSearch(view),
+    setOnRender: (fn) => {
+      view.onRender = fn;
+    }
+  };
+}
+
+export {
+  DevToolsConfigProvider,
+  useDevToolsConfig,
+  wsBaseFrom,
+  TYPE_U8,
+  TYPE_U16,
+  TYPE_U32,
+  TYPE_U64,
+  TYPE_S8,
+  TYPE_S16,
+  TYPE_S32,
+  TYPE_S64,
+  TYPE_BOOL,
+  TYPE_FLOAT32,
+  TYPE_FLOAT64,
+  TYPE_DATETIME,
+  TYPE_DOCUMENT,
+  getDevToolsToken,
+  setDevToolsToken,
+  clearDevToolsToken,
+  authHeaders,
+  fetchWhoAmI,
+  devToolsSignIn,
+  devToolsSignOut,
+  wsAuthProtocols,
+  BulkStreamProvider,
+  useBulkRowCounts,
+  useBulkSubscription
+};
+//# sourceMappingURL=chunk-3ZM6YOA4.js.map