tersejson 0.1.0

package/dist/index.js

@@ -0,0 +1,1001 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+function isTersePayload(value) {
+  return typeof value === "object" && value !== null && "__terse__" in value && value.__terse__ === true && "v" in value && "k" in value && "d" in value;
+}
+
+// src/core.ts
+function alphaGenerator(index) {
+  let key = "";
+  let remaining = index;
+  do {
+    key = String.fromCharCode(97 + remaining % 26) + key;
+    remaining = Math.floor(remaining / 26) - 1;
+  } while (remaining >= 0);
+  return key;
+}
+function numericGenerator(index) {
+  return String(index);
+}
+function alphanumericGenerator(index) {
+  const letterIndex = Math.floor(index / 9);
+  const numIndex = index % 9 + 1;
+  return alphaGenerator(letterIndex) + numIndex;
+}
+function shortGenerator(index) {
+  if (index === 0) return "_";
+  return alphaGenerator(index - 1);
+}
+function prefixedGenerator(prefix, style = "numeric") {
+  return (index) => {
+    if (style === "alpha") {
+      return prefix + alphaGenerator(index);
+    }
+    return prefix + index;
+  };
+}
+function createKeyGenerator(pattern) {
+  if (typeof pattern === "function") {
+    return { generator: pattern, name: "custom" };
+  }
+  if (typeof pattern === "string") {
+    switch (pattern) {
+      case "alpha":
+        return { generator: alphaGenerator, name: "alpha" };
+      case "numeric":
+        return { generator: numericGenerator, name: "numeric" };
+      case "alphanumeric":
+        return { generator: alphanumericGenerator, name: "alphanumeric" };
+      case "short":
+        return { generator: shortGenerator, name: "short" };
+      case "prefixed":
+        return { generator: prefixedGenerator("k"), name: "prefixed:k" };
+      default:
+        return { generator: alphaGenerator, name: "alpha" };
+    }
+  }
+  if (typeof pattern === "object" && "prefix" in pattern) {
+    return {
+      generator: prefixedGenerator(pattern.prefix, pattern.style || "numeric"),
+      name: `prefixed:${pattern.prefix}`
+    };
+  }
+  return { generator: alphaGenerator, name: "alpha" };
+}
+function resolveNestedDepth(handling, maxDepth) {
+  if (handling === void 0 || handling === "deep") {
+    return maxDepth;
+  }
+  if (handling === "shallow") {
+    return 1;
+  }
+  if (handling === "arrays") {
+    return maxDepth;
+  }
+  if (typeof handling === "number") {
+    return handling;
+  }
+  return maxDepth;
+}
+function collectKeys(data, options, currentDepth = 0) {
+  const keys = /* @__PURE__ */ new Set();
+  const { minKeyLength, maxDepth, nestedHandling, excludeKeys, includeKeys } = options;
+  if (currentDepth >= maxDepth) return keys;
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    for (const key of Object.keys(item)) {
+      if (excludeKeys?.includes(key)) continue;
+      const shouldInclude = includeKeys?.includes(key) || key.length >= minKeyLength;
+      if (shouldInclude) {
+        keys.add(key);
+        keyCounts.set(key, (keyCounts.get(key) || 0) + 1);
+      }
+      const value = item[key];
+      if (nestedHandling === "shallow") {
+        continue;
+      }
+      if (Array.isArray(value) && value.length > 0 && isCompressibleArray(value)) {
+        const nestedKeys = collectKeys(
+          value,
+          options,
+          currentDepth + 1
+        );
+        nestedKeys.forEach((k) => keys.add(k));
+      } else if (nestedHandling !== "arrays" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const nestedKeys = collectKeys(
+          [value],
+          options,
+          currentDepth + 1
+        );
+        nestedKeys.forEach((k) => keys.add(k));
+      }
+    }
+  }
+  if (options.homogeneousOnly && data.length > 0) {
+    for (const [key, count] of keyCounts) {
+      if (count < data.length) {
+        keys.delete(key);
+      }
+    }
+  }
+  return keys;
+}
+function isCompressibleArray(data) {
+  if (!Array.isArray(data) || data.length === 0) return false;
+  return data.every(
+    (item) => typeof item === "object" && item !== null && !Array.isArray(item)
+  );
+}
+function compressObject(obj, keyToShort, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return obj;
+  const compressed = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const shortKey = keyToShort.get(key) ?? key;
+    if (Array.isArray(value) && isCompressibleArray(value)) {
+      compressed[shortKey] = value.map(
+        (item) => compressObject(
+          item,
+          keyToShort,
+          maxDepth,
+          currentDepth + 1
+        )
+      );
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      compressed[shortKey] = compressObject(
+        value,
+        keyToShort,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else {
+      compressed[shortKey] = value;
+    }
+  }
+  return compressed;
+}
+function expandObject(obj, shortToKey, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth) return obj;
+  const expanded = {};
+  for (const [shortKey, value] of Object.entries(obj)) {
+    const originalKey = shortToKey.get(shortKey) ?? shortKey;
+    if (Array.isArray(value)) {
+      expanded[originalKey] = value.map((item) => {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          return expandObject(
+            item,
+            shortToKey,
+            maxDepth,
+            currentDepth + 1
+          );
+        }
+        return item;
+      });
+    } else if (typeof value === "object" && value !== null) {
+      expanded[originalKey] = expandObject(
+        value,
+        shortToKey,
+        maxDepth,
+        currentDepth + 1
+      );
+    } else {
+      expanded[originalKey] = value;
+    }
+  }
+  return expanded;
+}
+function compress(data, options = {}) {
+  const {
+    minKeyLength = 3,
+    maxDepth = 10,
+    keyPattern = "alpha",
+    nestedHandling = "deep",
+    homogeneousOnly = false,
+    excludeKeys,
+    includeKeys
+  } = options;
+  const { generator, name: patternName } = createKeyGenerator(keyPattern);
+  const effectiveDepth = resolveNestedDepth(nestedHandling, maxDepth);
+  const allKeys = collectKeys(data, {
+    minKeyLength,
+    maxDepth: effectiveDepth,
+    nestedHandling,
+    excludeKeys,
+    includeKeys,
+    homogeneousOnly
+  });
+  const sortedKeys = Array.from(allKeys).sort();
+  const keyToShort = /* @__PURE__ */ new Map();
+  const keyMap = {};
+  sortedKeys.forEach((key, index) => {
+    const shortKey = generator(index);
+    if (shortKey.length < key.length) {
+      keyToShort.set(key, shortKey);
+      keyMap[shortKey] = key;
+    }
+  });
+  const compressed = data.map(
+    (item) => compressObject(item, keyToShort, effectiveDepth)
+  );
+  return {
+    __terse__: true,
+    v: 1,
+    k: keyMap,
+    d: compressed,
+    p: patternName
+  };
+}
+function expand(payload) {
+  const shortToKey = new Map(
+    Object.entries(payload.k).map(([short, original]) => [short, original])
+  );
+  if (Array.isArray(payload.d)) {
+    return payload.d.map((item) => {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        return expandObject(item, shortToKey, 10);
+      }
+      return item;
+    });
+  }
+  if (typeof payload.d === "object" && payload.d !== null) {
+    return expandObject(payload.d, shortToKey, 10);
+  }
+  return payload.d;
+}
+function createTerseProxy(compressed, keyMap) {
+  const originalToShort = new Map(
+    Object.entries(keyMap).map(([short, original]) => [original, short])
+  );
+  const handler = {
+    get(target, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop);
+      }
+      const shortKey = originalToShort.get(prop);
+      const actualKey = shortKey ?? prop;
+      const value = target[actualKey];
+      if (Array.isArray(value)) {
+        return value.map((item) => {
+          if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+            return createTerseProxy(item, keyMap);
+          }
+          return item;
+        });
+      }
+      if (typeof value === "object" && value !== null) {
+        return createTerseProxy(value, keyMap);
+      }
+      return value;
+    },
+    has(target, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.has(target, prop);
+      }
+      const shortKey = originalToShort.get(prop);
+      return (shortKey ?? prop) in target;
+    },
+    ownKeys(target) {
+      return Object.keys(target).map((shortKey) => keyMap[shortKey] ?? shortKey);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+      const shortKey = originalToShort.get(prop);
+      const actualKey = shortKey ?? prop;
+      const descriptor = Object.getOwnPropertyDescriptor(target, actualKey);
+      if (descriptor) {
+        return { ...descriptor, enumerable: true, configurable: true };
+      }
+      return void 0;
+    }
+  };
+  return new Proxy(compressed, handler);
+}
+function wrapWithProxy(payload) {
+  if (Array.isArray(payload.d)) {
+    return payload.d.map((item) => {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        return createTerseProxy(item, payload.k);
+      }
+      return item;
+    });
+  }
+  if (typeof payload.d === "object" && payload.d !== null) {
+    return createTerseProxy(payload.d, payload.k);
+  }
+  return payload.d;
+}
+
+// src/express.ts
+var express_exports = {};
+__export(express_exports, {
+  TerseAnalytics: () => TerseAnalytics,
+  analytics: () => analytics,
+  default: () => express_default,
+  getAnalytics: () => getAnalytics,
+  initAnalytics: () => initAnalytics,
+  terse: () => terse,
+  terseQueryParam: () => terseQueryParam
+});
+
+// src/analytics.ts
+var DEFAULT_CONFIG = {
+  enabled: false,
+  reportToCloud: false,
+  reportInterval: 6e4,
+  trackEndpoints: false,
+  endpoint: "https://api.tersejson.com/v1/analytics",
+  debug: false
+};
+var TerseAnalytics = class {
+  constructor(config = {}) {
+    this.events = [];
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.isNode = typeof window === "undefined";
+    this.stats = this.createEmptyStats();
+    if (this.config.enabled && this.config.reportToCloud) {
+      this.startReporting();
+    }
+  }
+  /**
+   * Create empty stats object
+   */
+  createEmptyStats() {
+    return {
+      totalEvents: 0,
+      totalOriginalBytes: 0,
+      totalCompressedBytes: 0,
+      totalBytesSaved: 0,
+      averageRatio: 0,
+      totalObjects: 0,
+      sessionStart: Date.now(),
+      lastEvent: Date.now()
+    };
+  }
+  /**
+   * Record a compression event
+   */
+  record(event) {
+    if (!this.config.enabled) return;
+    const fullEvent = {
+      ...event,
+      timestamp: Date.now(),
+      // Hash endpoint for privacy if tracking is enabled
+      endpoint: this.config.trackEndpoints && event.endpoint ? this.hashEndpoint(event.endpoint) : void 0
+    };
+    this.stats.totalEvents++;
+    this.stats.totalOriginalBytes += event.originalSize;
+    this.stats.totalCompressedBytes += event.compressedSize;
+    this.stats.totalBytesSaved += event.originalSize - event.compressedSize;
+    this.stats.totalObjects += event.objectCount;
+    this.stats.lastEvent = fullEvent.timestamp;
+    this.stats.averageRatio = this.stats.totalCompressedBytes / this.stats.totalOriginalBytes;
+    this.events.push(fullEvent);
+    if (this.config.onEvent) {
+      this.config.onEvent(fullEvent);
+    }
+    if (this.config.debug) {
+      const savings = ((1 - event.compressedSize / event.originalSize) * 100).toFixed(1);
+      console.log(`[tersejson:analytics] ${event.originalSize} \u2192 ${event.compressedSize} bytes (${savings}% saved)`);
+    }
+  }
+  /**
+   * Get current stats
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Get formatted stats summary
+   */
+  getSummary() {
+    const stats = this.stats;
+    const savedKB = (stats.totalBytesSaved / 1024).toFixed(2);
+    const savedPercent = stats.totalOriginalBytes > 0 ? ((1 - stats.averageRatio) * 100).toFixed(1) : "0";
+    return `TerseJSON Stats: ${stats.totalEvents} compressions, ${savedKB}KB saved (${savedPercent}% avg)`;
+  }
+  /**
+   * Reset stats
+   */
+  reset() {
+    this.events = [];
+    this.stats = this.createEmptyStats();
+  }
+  /**
+   * Start periodic reporting to cloud
+   */
+  startReporting() {
+    if (this.reportTimer) return;
+    this.reportTimer = setInterval(() => {
+      this.reportToCloud();
+    }, this.config.reportInterval);
+    if (this.isNode && typeof process !== "undefined") {
+      process.on("beforeExit", () => this.reportToCloud());
+    }
+  }
+  /**
+   * Stop reporting
+   */
+  stop() {
+    if (this.reportTimer) {
+      clearInterval(this.reportTimer);
+      this.reportTimer = void 0;
+    }
+  }
+  /**
+   * Report stats to tersejson.com
+   */
+  async reportToCloud() {
+    if (!this.config.reportToCloud || this.events.length === 0) return;
+    const payload = {
+      apiKey: this.config.apiKey,
+      projectId: this.config.projectId,
+      stats: this.stats,
+      events: this.events.slice(-100),
+      // Last 100 events only
+      meta: {
+        version: "0.1.0",
+        runtime: this.isNode ? "node" : "browser"
+      }
+    };
+    try {
+      const fetchFn = this.isNode ? (await import('https')).request : globalThis.fetch;
+      if (this.isNode) {
+        const url = new URL(this.config.endpoint);
+        const req = fetchFn({
+          hostname: url.hostname,
+          port: url.port || 443,
+          path: url.pathname,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        req.write(JSON.stringify(payload));
+        req.end();
+      } else {
+        fetchFn(this.config.endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+          keepalive: true
+          // Allow sending on page unload
+        }).catch(() => {
+        });
+      }
+      this.events = [];
+      if (this.config.onStats) {
+        this.config.onStats(this.stats);
+      }
+      if (this.config.debug) {
+        console.log("[tersejson:analytics] Reported stats to cloud");
+      }
+    } catch {
+      if (this.config.debug) {
+        console.log("[tersejson:analytics] Failed to report stats");
+      }
+    }
+  }
+  /**
+   * Hash endpoint for privacy
+   */
+  hashEndpoint(endpoint) {
+    return endpoint.replace(/\/\d+/g, "/:id").replace(/\/[a-f0-9-]{36}/gi, "/:uuid").replace(/\?.*$/, "");
+  }
+};
+var globalAnalytics = null;
+function initAnalytics(config) {
+  globalAnalytics = new TerseAnalytics(config);
+  return globalAnalytics;
+}
+function getAnalytics() {
+  return globalAnalytics;
+}
+function recordEvent(event) {
+  globalAnalytics?.record(event);
+}
+var analytics = {
+  /**
+   * Enable local-only analytics (no cloud reporting)
+   */
+  local(options = {}) {
+    return initAnalytics({
+      enabled: true,
+      reportToCloud: false,
+      debug: options.debug,
+      onEvent: options.onEvent
+    });
+  },
+  /**
+   * Enable cloud analytics with API key
+   */
+  cloud(apiKey, options = {}) {
+    return initAnalytics({
+      ...options,
+      enabled: true,
+      reportToCloud: true,
+      apiKey
+    });
+  },
+  /**
+   * Get current stats
+   */
+  getStats() {
+    return globalAnalytics?.getStats() ?? null;
+  },
+  /**
+   * Get formatted summary
+   */
+  getSummary() {
+    return globalAnalytics?.getSummary() ?? "Analytics not initialized";
+  }
+};
+
+// src/express.ts
+var DEFAULT_OPTIONS = {
+  // Middleware-specific options
+  minArrayLength: 2,
+  shouldCompress: () => true,
+  headerName: "x-terse-json",
+  debug: false,
+  // CompressOptions
+  minKeyLength: 3,
+  maxDepth: 10,
+  keyPattern: "alpha",
+  nestedHandling: "deep",
+  homogeneousOnly: false,
+  excludeKeys: [],
+  includeKeys: []
+};
+function terse(options = {}) {
+  const { analytics: analyticsOption, ...restOptions } = options;
+  const config = { ...DEFAULT_OPTIONS, ...restOptions };
+  let analyticsInstance = null;
+  if (analyticsOption) {
+    if (analyticsOption instanceof TerseAnalytics) {
+      analyticsInstance = analyticsOption;
+    } else if (analyticsOption === true) {
+      analyticsInstance = new TerseAnalytics({ enabled: true, debug: config.debug });
+    } else if (typeof analyticsOption === "object") {
+      analyticsInstance = new TerseAnalytics({ enabled: true, ...analyticsOption });
+    }
+  }
+  return function terseMiddleware(req, res, next) {
+    const acceptsTerse = req.headers["accept-terse"] === "true" || req.headers["x-accept-terse"] === "true";
+    const originalJson = res.json.bind(res);
+    res.json = function terseJson(data) {
+      if (!acceptsTerse) {
+        return originalJson(data);
+      }
+      if (!isCompressibleArray(data)) {
+        return originalJson(data);
+      }
+      if (data.length < config.minArrayLength) {
+        return originalJson(data);
+      }
+      if (!config.shouldCompress(data, req)) {
+        return originalJson(data);
+      }
+      try {
+        const dataArray = data;
+        const compressed = compress(dataArray, {
+          minKeyLength: config.minKeyLength,
+          maxDepth: config.maxDepth,
+          keyPattern: config.keyPattern,
+          nestedHandling: config.nestedHandling,
+          homogeneousOnly: config.homogeneousOnly,
+          excludeKeys: config.excludeKeys,
+          includeKeys: config.includeKeys
+        });
+        const originalSize = JSON.stringify(data).length;
+        const compressedSize = JSON.stringify(compressed).length;
+        if (analyticsInstance) {
+          analyticsInstance.record({
+            originalSize,
+            compressedSize,
+            objectCount: dataArray.length,
+            keysCompressed: Object.keys(compressed.k).length,
+            endpoint: req.path,
+            keyPattern: compressed.p || "alpha"
+          });
+        }
+        recordEvent({
+          originalSize,
+          compressedSize,
+          objectCount: dataArray.length,
+          keysCompressed: Object.keys(compressed.k).length,
+          endpoint: req.path,
+          keyPattern: compressed.p || "alpha"
+        });
+        if (config.debug) {
+          const savings = ((1 - compressedSize / originalSize) * 100).toFixed(1);
+          console.log(
+            `[tersejson] Compressed ${originalSize} -> ${compressedSize} bytes (${savings}% savings)`
+          );
+        }
+        res.setHeader(config.headerName, "true");
+        return originalJson(compressed);
+      } catch (error) {
+        if (config.debug) {
+          console.error("[tersejson] Compression failed:", error);
+        }
+        return originalJson(data);
+      }
+    };
+    next();
+  };
+}
+function terseQueryParam(paramName = "terse") {
+  return function terseQueryMiddleware(req, _res, next) {
+    if (req.query[paramName] === "true") {
+      req.headers["accept-terse"] = "true";
+    }
+    next();
+  };
+}
+var express_default = terse;
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  axiosInterceptor: () => axiosInterceptor,
+  createFetch: () => createFetch,
+  default: () => client_default,
+  expand: () => expand,
+  fetch: () => fetch,
+  isTersePayload: () => isTersePayload,
+  process: () => process2,
+  proxy: () => wrapWithProxy,
+  useTerseFetch: () => useTerseFetch
+});
+var DEFAULT_OPTIONS2 = {
+  headerName: "x-terse-json",
+  debug: false,
+  autoExpand: true
+};
+function process2(data, options = {}) {
+  const { useProxy = true } = options;
+  if (isTersePayload(data)) {
+    return useProxy ? wrapWithProxy(data) : expand(data);
+  }
+  return data;
+}
+function createFetch(options = {}) {
+  const config = { ...DEFAULT_OPTIONS2, ...options };
+  return async function terseFetch(input, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("accept-terse", "true");
+    const response = await globalThis.fetch(input, {
+      ...init,
+      headers
+    });
+    const isTerse = response.headers.get(config.headerName) === "true";
+    if (!isTerse || !config.autoExpand) {
+      return response;
+    }
+    const clonedResponse = response.clone();
+    return new Proxy(response, {
+      get(target, prop) {
+        if (prop === "json") {
+          return async function() {
+            const data = await clonedResponse.json();
+            if (isTersePayload(data)) {
+              if (config.debug) {
+                console.log("[tersejson] Expanding terse response");
+              }
+              return wrapWithProxy(data);
+            }
+            return data;
+          };
+        }
+        const value = Reflect.get(target, prop);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  };
+}
+var fetch = createFetch();
+function useTerseFetch(options = {}) {
+  return createFetch(options);
+}
+var axiosInterceptor = {
+  request: (config) => {
+    config.headers = config.headers || {};
+    config.headers["accept-terse"] = "true";
+    return config;
+  },
+  response: (response) => {
+    const isTerse = response.headers?.["x-terse-json"] === "true";
+    if (isTerse && isTersePayload(response.data)) {
+      response.data = wrapWithProxy(response.data);
+    }
+    return response;
+  }
+};
+var client_default = { fetch, createFetch, expand, proxy: wrapWithProxy, process: process2 };
+
+// src/integrations.ts
+var integrations_exports = {};
+__export(integrations_exports, {
+  angularInterceptorSnippet: () => angularInterceptorSnippet,
+  angularJSInterceptorSnippet: () => angularJSInterceptorSnippet,
+  axiosInterceptors: () => axiosInterceptors,
+  createAngularInterceptor: () => createAngularInterceptor,
+  createAngularJSInterceptor: () => createAngularJSInterceptor,
+  createAxiosInterceptors: () => createAxiosInterceptors,
+  createQueryFn: () => createQueryFn,
+  createSWRFetcher: () => createSWRFetcher,
+  default: () => integrations_default,
+  jQuerySetupSnippet: () => jQuerySetupSnippet,
+  setupJQueryAjax: () => setupJQueryAjax
+});
+function createAxiosInterceptors(options = {}) {
+  const { useProxy = true, debug = false } = options;
+  return {
+    request: (config) => {
+      if (config.headers) {
+        if (typeof config.headers.set === "function") {
+          config.headers.set("accept-terse", "true");
+        } else {
+          config.headers["accept-terse"] = "true";
+        }
+      } else {
+        config.headers = { "accept-terse": "true" };
+      }
+      return config;
+    },
+    response: (response) => {
+      let isTerse = false;
+      if (response.headers) {
+        if (typeof response.headers.get === "function") {
+          isTerse = response.headers.get("x-terse-json") === "true";
+        } else {
+          isTerse = response.headers["x-terse-json"] === "true";
+        }
+      }
+      if (isTerse && isTersePayload(response.data)) {
+        if (debug) {
+          console.log("[tersejson] Expanding Axios response");
+        }
+        response.data = useProxy ? wrapWithProxy(response.data) : expand(response.data);
+      }
+      return response;
+    }
+  };
+}
+var axiosInterceptors = createAxiosInterceptors();
+function createAngularInterceptor(options = {}) {
+  const { useProxy = true, debug = false } = options;
+  return {
+    /**
+     * Modifies the request to include the accept-terse header
+     */
+    modifyRequest: (req) => {
+      return req.clone({
+        setHeaders: {
+          "accept-terse": "true"
+        }
+      });
+    },
+    /**
+     * Processes the response to expand TerseJSON payloads
+     */
+    processResponse: (event) => {
+      if (event.type === 4 && event.body !== void 0) {
+        const isTerse = event.headers?.get("x-terse-json") === "true";
+        if (isTerse && isTersePayload(event.body)) {
+          if (debug) {
+            console.log("[tersejson] Expanding Angular response");
+          }
+          return {
+            ...event,
+            body: useProxy ? wrapWithProxy(event.body) : expand(event.body)
+          };
+        }
+      }
+      return event;
+    }
+  };
+}
+var angularInterceptorSnippet = `
+// terse.interceptor.ts
+import { Injectable } from '@angular/core';
+import {
+  HttpInterceptor,
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpResponse
+} from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { isTersePayload, wrapWithProxy } from 'tersejson';
+
+@Injectable()
+export class TerseInterceptor implements HttpInterceptor {
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    // Add accept-terse header
+    const terseReq = req.clone({
+      setHeaders: { 'accept-terse': 'true' }
+    });
+
+    return next.handle(terseReq).pipe(
+      map(event => {
+        if (event instanceof HttpResponse && event.body) {
+          const isTerse = event.headers.get('x-terse-json') === 'true';
+          if (isTerse && isTersePayload(event.body)) {
+            return event.clone({ body: wrapWithProxy(event.body) });
+          }
+        }
+        return event;
+      })
+    );
+  }
+}
+
+// app.module.ts - Add to providers:
+// { provide: HTTP_INTERCEPTORS, useClass: TerseInterceptor, multi: true }
+`;
+function createAngularJSInterceptor(options = {}) {
+  const { useProxy = true, debug = false } = options;
+  return {
+    /**
+     * Request interceptor - adds accept-terse header
+     */
+    request: (config) => {
+      config.headers = config.headers || {};
+      config.headers["accept-terse"] = "true";
+      return config;
+    },
+    /**
+     * Response interceptor - expands TerseJSON payloads
+     */
+    response: (response) => {
+      const isTerse = response.headers("x-terse-json") === "true";
+      if (isTerse && isTersePayload(response.data)) {
+        if (debug) {
+          console.log("[tersejson] Expanding AngularJS response");
+        }
+        response.data = useProxy ? wrapWithProxy(response.data) : expand(response.data);
+      }
+      return response;
+    }
+  };
+}
+var angularJSInterceptorSnippet = `
+// Setup TerseJSON with AngularJS
+angular.module('myApp', [])
+  .factory('terseInterceptor', ['$q', function($q) {
+    return {
+      request: function(config) {
+        config.headers = config.headers || {};
+        config.headers['accept-terse'] = 'true';
+        return config;
+      },
+      response: function(response) {
+        var isTerse = response.headers('x-terse-json') === 'true';
+        if (isTerse && response.data && response.data.__terse__) {
+          // Use tersejson.process() or tersejson.wrapWithProxy()
+          response.data = tersejson.process(response.data);
+        }
+        return response;
+      }
+    };
+  }])
+  .config(['$httpProvider', function($httpProvider) {
+    $httpProvider.interceptors.push('terseInterceptor');
+  }]);
+`;
+function setupJQueryAjax($, options = {}) {
+  const { useProxy = true, debug = false } = options;
+  $.ajaxSetup({
+    headers: {
+      "accept-terse": "true"
+    }
+  });
+  $.ajaxPrefilter((ajaxOptions) => {
+    const originalDataFilter = ajaxOptions.dataFilter;
+    ajaxOptions.dataFilter = function(data, type) {
+      let processed = data;
+      if (originalDataFilter) {
+        processed = originalDataFilter(data, type);
+      }
+      if (type === "json" || type === void 0) {
+        try {
+          const parsed = typeof processed === "string" ? JSON.parse(processed) : processed;
+          if (isTersePayload(parsed)) {
+            if (debug) {
+              console.log("[tersejson] Expanding jQuery response");
+            }
+            return useProxy ? wrapWithProxy(parsed) : expand(parsed);
+          }
+          return parsed;
+        } catch {
+          return processed;
+        }
+      }
+      return processed;
+    };
+  });
+}
+var jQuerySetupSnippet = `
+// Setup TerseJSON with jQuery
+$.ajaxSetup({
+  headers: { 'accept-terse': 'true' },
+  dataFilter: function(data, type) {
+    if (type === 'json') {
+      var parsed = JSON.parse(data);
+      if (parsed && parsed.__terse__) {
+        return tersejson.process(parsed);
+      }
+      return parsed;
+    }
+    return data;
+  }
+});
+`;
+function createSWRFetcher(options = {}) {
+  const { useProxy = true, debug = false } = options;
+  return async (url) => {
+    const response = await globalThis.fetch(url, {
+      headers: {
+        "accept-terse": "true"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    if (isTersePayload(data)) {
+      if (debug) {
+        console.log("[tersejson] Expanding SWR response");
+      }
+      return useProxy ? wrapWithProxy(data) : expand(data);
+    }
+    return data;
+  };
+}
+var createQueryFn = createSWRFetcher;
+var integrations_default = {
+  // Axios
+  createAxiosInterceptors,
+  axiosInterceptors,
+  // Angular
+  createAngularInterceptor,
+  angularInterceptorSnippet,
+  // AngularJS
+  createAngularJSInterceptor,
+  angularJSInterceptorSnippet,
+  // jQuery
+  setupJQueryAjax,
+  jQuerySetupSnippet,
+  // SWR / React Query
+  createSWRFetcher,
+  createQueryFn
+};
+
+exports.TerseAnalytics = TerseAnalytics;
+exports.analytics = analytics;
+exports.client = client_exports;
+exports.compress = compress;
+exports.createKeyGenerator = createKeyGenerator;
+exports.createTerseProxy = createTerseProxy;
+exports.expand = expand;
+exports.express = express_exports;
+exports.getAnalytics = getAnalytics;
+exports.initAnalytics = initAnalytics;
+exports.integrations = integrations_exports;
+exports.isCompressibleArray = isCompressibleArray;
+exports.isTersePayload = isTersePayload;
+exports.recordEvent = recordEvent;
+exports.wrapWithProxy = wrapWithProxy;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map