@q9labsai/chalk-react 4.1.15 → 4.1.16

package/dist/chunk-FFPNO2MY.js

@@ -0,0 +1,131 @@
+// src/utils/feedback.ts
+import { domToJpeg } from "modern-screenshot";
+var MAX_SCREENSHOT_BYTES = 450 * 1024;
+var MAX_SCREENSHOT_WIDTH = 1920;
+var MAX_SCREENSHOT_HEIGHT = 1080;
+var SAFE_COOKIE_NAMES = /* @__PURE__ */ new Set(["chalk_theme", "chalk_sidebar_state", "account", "csrf", "__Host-chalk_account", "chalk_account_local", "__Host-chalk_csrf", "chalk_csrf_local"]);
+var ACCOUNT_COOKIE_NAMES = ["account", "__Host-chalk_account", "chalk_account_local"];
+var CSRF_COOKIE_NAMES = ["csrf", "__Host-chalk_csrf", "chalk_csrf_local"];
+function collectBrowserFeedbackEvidence() {
+  const tenantHint = readTenantHint();
+  const telemetry = readTelemetrySummary();
+  const dashboardRequests = readDashboardRequests();
+  return {
+    sdk: { client: "@q9labsai/chalk-client", react: "@q9labsai/chalk-react" },
+    platform: { kind: "web", ...browserMetadata() },
+    local_state: {
+      ...tenantHint ? { tenant_hint: tenantHint } : {},
+      ...telemetry ? { telemetry } : {},
+      ...dashboardRequests.length > 0 ? { dashboard_requests: dashboardRequests } : {}
+    },
+    cookies: readFeedbackCookies()
+  };
+}
+async function captureFeedbackScreenshot(root) {
+  if (!root || typeof window === "undefined") return { state: "unavailable", failure_code: "unsupported" };
+  try {
+    const bounds = root.getBoundingClientRect();
+    const width = Math.round(bounds.width);
+    const height = Math.round(bounds.height);
+    if (width <= 0 || height <= 0) return { state: "unavailable", failure_code: "unsupported" };
+    const dataUrl = await domToJpeg(root, {
+      quality: 0.78,
+      width: Math.min(width, MAX_SCREENSHOT_WIDTH),
+      height: Math.min(height, MAX_SCREENSHOT_HEIGHT),
+      filter: (node) => !(node instanceof Element && Boolean(node.closest("[data-chalk-feedback-private], [data-chalk-host-content]")))
+    });
+    const separator = dataUrl.indexOf(",");
+    if (separator < 0) return { state: "unavailable", failure_code: "capture_failed" };
+    const encoded = dataUrl.slice(separator + 1);
+    if (encoded.length * 0.75 > MAX_SCREENSHOT_BYTES) return { state: "unavailable", failure_code: "too_large" };
+    return {
+      state: "captured",
+      mime_type: "image/jpeg",
+      width: Math.min(width, MAX_SCREENSHOT_WIDTH),
+      height: Math.min(height, MAX_SCREENSHOT_HEIGHT),
+      captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+      data_base64: encoded
+    };
+  } catch {
+    return { state: "unavailable", failure_code: "capture_failed" };
+  }
+}
+function browserMetadata() {
+  if (typeof navigator === "undefined") return {};
+  return {
+    browser_name: browserName(navigator.userAgent),
+    device_class: typeof window !== "undefined" && window.matchMedia?.("(pointer: coarse)").matches ? "phone" : "desktop"
+  };
+}
+function browserName(userAgent) {
+  if (/edg\//iu.test(userAgent)) return "Edge";
+  if (/firefox\//iu.test(userAgent)) return "Firefox";
+  if (/chrome\//iu.test(userAgent)) return "Chrome";
+  if (/safari\//iu.test(userAgent)) return "Safari";
+  return void 0;
+}
+function readTenantHint() {
+  try {
+    const value = window.localStorage.getItem("chalk.tenant-hint") ?? void 0;
+    return value && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readTelemetrySummary() {
+  try {
+    let pendingCount = 0;
+    let found = false;
+    for (let index = 0; index < window.localStorage.length; index += 1) {
+      const key = window.localStorage.key(index);
+      if (key !== "chalk.web.telemetry.v1" && !key?.startsWith("chalk.web.telemetry.v1.")) continue;
+      const raw = key ? window.localStorage.getItem(key) : null;
+      if (!raw) continue;
+      const value = JSON.parse(raw);
+      if (!Array.isArray(value)) continue;
+      found = true;
+      pendingCount = Math.min(500, pendingCount + value.length);
+    }
+    return found ? { storage_key: "chalk.web.telemetry.v1", pending_count: pendingCount } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readDashboardRequests() {
+  try {
+    const requests = [];
+    for (let index = 0; index < window.localStorage.length; index += 1) {
+      const key = window.localStorage.key(index);
+      if (!key?.startsWith("chalk.dashboard-request.")) continue;
+      const action = key.slice("chalk.dashboard-request.".length);
+      if (!/^[a-z][a-z0-9_-]{0,63}$/u.test(action)) continue;
+      requests.push({ action, pending: true });
+    }
+    return requests.slice(0, 32);
+  } catch {
+    return [];
+  }
+}
+function readFeedbackCookies() {
+  if (typeof document === "undefined") return {};
+  const values = /* @__PURE__ */ new Map();
+  for (const item of document.cookie.split(";")) {
+    const separator = item.indexOf("=");
+    if (separator < 0) continue;
+    const name = item.slice(0, separator).trim();
+    if (SAFE_COOKIE_NAMES.has(name)) values.set(name, item.slice(separator + 1));
+  }
+  const theme = values.get("chalk_theme");
+  const sidebarState = values.get("chalk_sidebar_state");
+  return {
+    ...theme === "light" || theme === "dark" || theme === "system" ? { theme } : {},
+    ...sidebarState === "true" || sidebarState === "false" ? { sidebar_state: sidebarState === "true" } : {},
+    account_present: ACCOUNT_COOKIE_NAMES.some((name) => values.has(name)),
+    csrf_present: CSRF_COOKIE_NAMES.some((name) => values.has(name))
+  };
+}
+
+export {
+  collectBrowserFeedbackEvidence,
+  captureFeedbackScreenshot
+};

package/dist/chunk-HZ43I4OS.js

@@ -0,0 +1,138 @@
+// src/components/whiteboard-view/recording-whiteboard-state.ts
+var RECORDING_WHITEBOARD_STATE_KEYS = ["schemaVersion", "sceneId", "revision", "appState", "elements"];
+var RECORDING_WHITEBOARD_APP_STATE_KEYS = ["view_background_color"];
+var WHITEBOARD_WIRE_ELEMENT_KEYS = ["id", "type", "version", "version_nonce", "index", "is_deleted", "payload"];
+var MAX_VIEW_BACKGROUND_COLOR_BYTES = 64;
+var EXCALIDRAW_FILE_MIME_TYPES = /* @__PURE__ */ new Set(["image/svg+xml", "image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp", "image/x-icon", "image/avif", "image/jfif", "application/octet-stream"]);
+function parseRecordingWhiteboardStateV1(value) {
+  if (!isRecordingWhiteboardStateInput(value)) throw invalidState();
+  if (value.schemaVersion !== "recording_whiteboard_state.v1" || !isNonEmptyString(value.sceneId) || !isNonNegativeSafeInteger(value.revision)) throw invalidState();
+  const appState = parseRecordingWhiteboardAppState(value.appState);
+  if (!Array.isArray(value.elements) || !value.elements.every(isWhiteboardWireElement)) throw invalidState();
+  if (!isCanonicalElementOrder(value.elements)) throw new TypeError("recording whiteboard elements are not in canonical order");
+  return Object.freeze({
+    schemaVersion: value.schemaVersion,
+    sceneId: value.sceneId,
+    revision: value.revision,
+    appState,
+    elements: Object.freeze([...value.elements])
+  });
+}
+function recordingWhiteboardFileIds(state) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const element of state.elements) {
+    if (element.is_deleted) continue;
+    const fileId = element.payload.fileId;
+    if (isNonEmptyString(fileId)) ids.add(fileId);
+  }
+  return Object.freeze([...ids].sort());
+}
+function recordingWhiteboardFileAssetId(fileId) {
+  if (!isNonEmptyString(fileId)) throw new TypeError("recording whiteboard file id is invalid");
+  return `whiteboard_file:${fileId}`;
+}
+function recordingWhiteboardSceneAppState(state, defaultViewBackgroundColor) {
+  return Object.freeze({ viewBackgroundColor: state.appState.view_background_color ?? defaultViewBackgroundColor });
+}
+function recordingWhiteboardBinaryFile({ fileId, mimeType, dataURL, createdAtMs = 0 }) {
+  if (!isRecordingWhiteboardFileId(fileId) || !isNonNegativeSafeInteger(createdAtMs)) throw new TypeError("recording whiteboard file is invalid");
+  const normalizedMimeType = normalizedFileMimeType(mimeType);
+  if (!isRecordingWhiteboardDataURL(dataURL, normalizedMimeType)) throw new TypeError("recording whiteboard file data URL is invalid");
+  return Object.freeze({ id: fileId, mimeType: normalizedMimeType, dataURL, created: createdAtMs });
+}
+async function loadRecordingWhiteboardFiles(state, resolve) {
+  const pairs = await Promise.all(
+    recordingWhiteboardFileIds(state).map(async (fileId) => {
+      const source = await resolve(Object.freeze({ fileId, assetId: recordingWhiteboardFileAssetId(fileId) }));
+      return [fileId, recordingWhiteboardBinaryFile({ fileId, ...source })];
+    })
+  );
+  const files = {};
+  for (const [fileId, file] of pairs) files[fileId] = file;
+  return Object.freeze(files);
+}
+function isRecordingWhiteboardStateInput(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return hasExactKeys(value, RECORDING_WHITEBOARD_STATE_KEYS);
+}
+function isWhiteboardWireElement(value) {
+  if (!isWhiteboardWireElementInput(value)) return false;
+  return isNonEmptyString(value.id) && isNonEmptyString(value.type) && isNonNegativeSafeInteger(value.version) && isNonNegativeSafeInteger(value.version_nonce) && isNonEmptyString(value.index) && typeof value.is_deleted === "boolean" && isWhiteboardElementPayload(value.payload);
+}
+function isWhiteboardWireElementInput(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return hasExactKeys(value, WHITEBOARD_WIRE_ELEMENT_KEYS);
+}
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function isCanonicalElementOrder(elements) {
+  let previous;
+  for (const current of elements) {
+    if (previous === void 0) {
+      previous = current;
+      continue;
+    }
+    if (previous.index > current.index || previous.index === current.index && previous.id > current.id) return false;
+    previous = current;
+  }
+  return true;
+}
+function parseRecordingWhiteboardAppState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalidState();
+  const keys = Object.keys(value);
+  if (keys.length === 0) return Object.freeze({});
+  if (!hasExactKeys(value, RECORDING_WHITEBOARD_APP_STATE_KEYS) || !("view_background_color" in value) || !isViewBackgroundColor(value.view_background_color)) throw invalidState();
+  return Object.freeze({ view_background_color: value.view_background_color });
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function normalizedFileMimeType(value) {
+  const [rawMimeType] = value.split(";", 1);
+  const mimeType = rawMimeType?.trim().toLowerCase();
+  if (!mimeType || !isRecordingWhiteboardFileMimeType(mimeType)) throw new TypeError("recording whiteboard file MIME type is unsupported");
+  return mimeType;
+}
+function isRecordingWhiteboardDataURL(value, mimeType) {
+  if (!value.startsWith("data:") || !value.includes(",")) return false;
+  const encodedMimeType = value.slice(5, value.indexOf(",")).split(";", 1)[0]?.trim().toLowerCase();
+  return encodedMimeType === mimeType;
+}
+function isRecordingWhiteboardFileId(value) {
+  return isNonEmptyString(value);
+}
+function isRecordingWhiteboardFileMimeType(value) {
+  return EXCALIDRAW_FILE_MIME_TYPES.has(value);
+}
+function isViewBackgroundColor(value) {
+  return typeof value === "string" && new TextEncoder().encode(value).byteLength <= MAX_VIEW_BACKGROUND_COLOR_BYTES;
+}
+function isWhiteboardElementPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return Object.values(value).every((item) => isWhiteboardJsonValue(item, 0));
+}
+function isWhiteboardJsonValue(value, depth) {
+  if (depth > 16) return false;
+  if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isWhiteboardJsonValue(item, depth + 1));
+  if (typeof value !== "object") return false;
+  return Object.values(value).every((item) => isWhiteboardJsonValue(item, depth + 1));
+}
+function invalidState() {
+  return new TypeError("recording whiteboard state is invalid");
+}
+
+export {
+  parseRecordingWhiteboardStateV1,
+  recordingWhiteboardFileIds,
+  recordingWhiteboardFileAssetId,
+  recordingWhiteboardSceneAppState,
+  recordingWhiteboardBinaryFile,
+  loadRecordingWhiteboardFiles
+};