tersejson 0.1.0

package/dist/integrations-7WeFO1Lk.d.ts

@@ -0,0 +1,264 @@
+/**
+ * TerseJSON Framework Integrations
+ *
+ * Ready-to-use integrations for popular HTTP clients and frameworks.
+ */
+/**
+ * Axios request interceptor type
+ */
+interface AxiosRequestConfig {
+    headers?: Record<string, string> | {
+        set?: (key: string, value: string) => void;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Axios response type
+ */
+interface AxiosResponse<T = unknown> {
+    data: T;
+    headers: Record<string, string> | {
+        get?: (key: string) => string | null;
+    };
+    status: number;
+    statusText: string;
+    config: AxiosRequestConfig;
+    [key: string]: unknown;
+}
+/**
+ * Create Axios interceptors for TerseJSON support
+ *
+ * @example
+ * ```typescript
+ * import axios from 'axios';
+ * import { createAxiosInterceptors } from 'tersejson/integrations';
+ *
+ * const { request, response } = createAxiosInterceptors();
+ * axios.interceptors.request.use(request);
+ * axios.interceptors.response.use(response);
+ *
+ * // Now all axios requests automatically handle TerseJSON
+ * const { data } = await axios.get('/api/users');
+ * console.log(data[0].firstName); // Works transparently!
+ * ```
+ */
+declare function createAxiosInterceptors(options?: {
+    useProxy?: boolean;
+    debug?: boolean;
+}): {
+    request: <T extends AxiosRequestConfig>(config: T) => T;
+    response: <T>(response: AxiosResponse<T>) => AxiosResponse<T>;
+};
+/**
+ * Pre-configured Axios interceptors (convenience export)
+ */
+declare const axiosInterceptors: {
+    request: <T extends AxiosRequestConfig>(config: T) => T;
+    response: <T>(response: AxiosResponse<T>) => AxiosResponse<T>;
+};
+/**
+ * Angular HttpInterceptor interface (simplified)
+ */
+interface HttpRequest<T = unknown> {
+    clone: (options: {
+        setHeaders?: Record<string, string>;
+    }) => HttpRequest<T>;
+    [key: string]: unknown;
+}
+interface HttpEvent<T = unknown> {
+    type?: number;
+    body?: T;
+    headers?: {
+        get: (name: string) => string | null;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Creates an Angular HTTP interceptor for TerseJSON support
+ *
+ * @example
+ * ```typescript
+ * // 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 { createAngularInterceptor } from 'tersejson/integrations';
+ *
+ * @Injectable()
+ * export class TerseInterceptor implements HttpInterceptor {
+ *   private handler = createAngularInterceptor();
+ *
+ *   intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+ *     return this.handler(req, next);
+ *   }
+ * }
+ *
+ * // app.module.ts
+ * providers: [
+ *   { provide: HTTP_INTERCEPTORS, useClass: TerseInterceptor, multi: true }
+ * ]
+ * ```
+ */
+declare function createAngularInterceptor(options?: {
+    useProxy?: boolean;
+    debug?: boolean;
+}): {
+    /**
+     * Modifies the request to include the accept-terse header
+     */
+    modifyRequest: <T>(req: HttpRequest<T>) => HttpRequest<T>;
+    /**
+     * Processes the response to expand TerseJSON payloads
+     */
+    processResponse: <T>(event: HttpEvent<T>) => HttpEvent<T>;
+};
+/**
+ * Angular interceptor code snippet for copy-paste
+ * Since Angular interceptors require decorators, we provide the implementation
+ */
+declare const angularInterceptorSnippet = "\n// terse.interceptor.ts\nimport { Injectable } from '@angular/core';\nimport {\n  HttpInterceptor,\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n  HttpResponse\n} from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { isTersePayload, wrapWithProxy } from 'tersejson';\n\n@Injectable()\nexport class TerseInterceptor implements HttpInterceptor {\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n    // Add accept-terse header\n    const terseReq = req.clone({\n      setHeaders: { 'accept-terse': 'true' }\n    });\n\n    return next.handle(terseReq).pipe(\n      map(event => {\n        if (event instanceof HttpResponse && event.body) {\n          const isTerse = event.headers.get('x-terse-json') === 'true';\n          if (isTerse && isTersePayload(event.body)) {\n            return event.clone({ body: wrapWithProxy(event.body) });\n          }\n        }\n        return event;\n      })\n    );\n  }\n}\n\n// app.module.ts - Add to providers:\n// { provide: HTTP_INTERCEPTORS, useClass: TerseInterceptor, multi: true }\n";
+/**
+ * AngularJS $http config type
+ */
+interface AngularJSHttpConfig {
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * AngularJS $http response type
+ */
+interface AngularJSHttpResponse<T = unknown> {
+    data: T;
+    headers: (name: string) => string | null;
+    status: number;
+    statusText: string;
+    config: AngularJSHttpConfig;
+}
+/**
+ * Creates AngularJS $http interceptor for TerseJSON support
+ *
+ * @example
+ * ```javascript
+ * // In your AngularJS app config
+ * angular.module('myApp', [])
+ *   .config(['$httpProvider', function($httpProvider) {
+ *     $httpProvider.interceptors.push(['$q', function($q) {
+ *       return createAngularJSInterceptor();
+ *     }]);
+ *   }]);
+ * ```
+ */
+declare function createAngularJSInterceptor(options?: {
+    useProxy?: boolean;
+    debug?: boolean;
+}): {
+    /**
+     * Request interceptor - adds accept-terse header
+     */
+    request: <T extends AngularJSHttpConfig>(config: T) => T;
+    /**
+     * Response interceptor - expands TerseJSON payloads
+     */
+    response: <T>(response: AngularJSHttpResponse<T>) => AngularJSHttpResponse<T>;
+};
+/**
+ * AngularJS setup code snippet
+ */
+declare const angularJSInterceptorSnippet = "\n// Setup TerseJSON with AngularJS\nangular.module('myApp', [])\n  .factory('terseInterceptor', ['$q', function($q) {\n    return {\n      request: function(config) {\n        config.headers = config.headers || {};\n        config.headers['accept-terse'] = 'true';\n        return config;\n      },\n      response: function(response) {\n        var isTerse = response.headers('x-terse-json') === 'true';\n        if (isTerse && response.data && response.data.__terse__) {\n          // Use tersejson.process() or tersejson.wrapWithProxy()\n          response.data = tersejson.process(response.data);\n        }\n        return response;\n      }\n    };\n  }])\n  .config(['$httpProvider', function($httpProvider) {\n    $httpProvider.interceptors.push('terseInterceptor');\n  }]);\n";
+/**
+ * jQuery AJAX setup for TerseJSON
+ *
+ * @example
+ * ```javascript
+ * import { setupJQueryAjax } from 'tersejson/integrations';
+ * setupJQueryAjax($);
+ *
+ * // Now $.ajax, $.get, $.post all support TerseJSON
+ * $.get('/api/users', function(data) {
+ *   console.log(data[0].firstName); // Works!
+ * });
+ * ```
+ */
+declare function setupJQueryAjax($: {
+    ajaxSetup: (options: unknown) => void;
+    ajaxPrefilter: (callback: unknown) => void;
+}, options?: {
+    useProxy?: boolean;
+    debug?: boolean;
+}): void;
+/**
+ * jQuery setup code snippet
+ */
+declare const jQuerySetupSnippet = "\n// Setup TerseJSON with jQuery\n$.ajaxSetup({\n  headers: { 'accept-terse': 'true' },\n  dataFilter: function(data, type) {\n    if (type === 'json') {\n      var parsed = JSON.parse(data);\n      if (parsed && parsed.__terse__) {\n        return tersejson.process(parsed);\n      }\n      return parsed;\n    }\n    return data;\n  }\n});\n";
+/**
+ * Creates a fetcher for SWR with TerseJSON support
+ *
+ * @example
+ * ```typescript
+ * import useSWR from 'swr';
+ * import { createSWRFetcher } from 'tersejson/integrations';
+ *
+ * const fetcher = createSWRFetcher();
+ *
+ * function UserList() {
+ *   const { data, error } = useSWR('/api/users', fetcher);
+ *   return <div>{data?.[0].firstName}</div>;
+ * }
+ * ```
+ */
+declare function createSWRFetcher(options?: {
+    useProxy?: boolean;
+    debug?: boolean;
+}): <T>(url: string) => Promise<T>;
+/**
+ * Creates a query function for React Query / TanStack Query
+ *
+ * @example
+ * ```typescript
+ * import { useQuery } from '@tanstack/react-query';
+ * import { createQueryFn } from 'tersejson/integrations';
+ *
+ * const queryFn = createQueryFn();
+ *
+ * function UserList() {
+ *   const { data } = useQuery({
+ *     queryKey: ['users'],
+ *     queryFn: () => queryFn('/api/users')
+ *   });
+ *   return <div>{data?.[0].firstName}</div>;
+ * }
+ * ```
+ */
+declare const createQueryFn: typeof createSWRFetcher;
+declare const _default: {
+    createAxiosInterceptors: typeof createAxiosInterceptors;
+    axiosInterceptors: {
+        request: <T extends AxiosRequestConfig>(config: T) => T;
+        response: <T>(response: AxiosResponse<T>) => AxiosResponse<T>;
+    };
+    createAngularInterceptor: typeof createAngularInterceptor;
+    angularInterceptorSnippet: string;
+    createAngularJSInterceptor: typeof createAngularJSInterceptor;
+    angularJSInterceptorSnippet: string;
+    setupJQueryAjax: typeof setupJQueryAjax;
+    jQuerySetupSnippet: string;
+    createSWRFetcher: typeof createSWRFetcher;
+    createQueryFn: typeof createSWRFetcher;
+};
+
+declare const integrations_angularInterceptorSnippet: typeof angularInterceptorSnippet;
+declare const integrations_angularJSInterceptorSnippet: typeof angularJSInterceptorSnippet;
+declare const integrations_axiosInterceptors: typeof axiosInterceptors;
+declare const integrations_createAngularInterceptor: typeof createAngularInterceptor;
+declare const integrations_createAngularJSInterceptor: typeof createAngularJSInterceptor;
+declare const integrations_createAxiosInterceptors: typeof createAxiosInterceptors;
+declare const integrations_createQueryFn: typeof createQueryFn;
+declare const integrations_createSWRFetcher: typeof createSWRFetcher;
+declare const integrations_jQuerySetupSnippet: typeof jQuerySetupSnippet;
+declare const integrations_setupJQueryAjax: typeof setupJQueryAjax;
+declare namespace integrations {
+  export { integrations_angularInterceptorSnippet as angularInterceptorSnippet, integrations_angularJSInterceptorSnippet as angularJSInterceptorSnippet, integrations_axiosInterceptors as axiosInterceptors, integrations_createAngularInterceptor as createAngularInterceptor, integrations_createAngularJSInterceptor as createAngularJSInterceptor, integrations_createAxiosInterceptors as createAxiosInterceptors, integrations_createQueryFn as createQueryFn, integrations_createSWRFetcher as createSWRFetcher, _default as default, integrations_jQuerySetupSnippet as jQuerySetupSnippet, integrations_setupJQueryAjax as setupJQueryAjax };
+}
+
+export { _default as _, axiosInterceptors as a, createAngularInterceptor as b, createAxiosInterceptors as c, angularInterceptorSnippet as d, createAngularJSInterceptor as e, angularJSInterceptorSnippet as f, createSWRFetcher as g, createQueryFn as h, integrations as i, jQuerySetupSnippet as j, setupJQueryAjax as s };

package/dist/integrations.d.mts

@@ -0,0 +1 @@
+export { d as angularInterceptorSnippet, f as angularJSInterceptorSnippet, a as axiosInterceptors, b as createAngularInterceptor, e as createAngularJSInterceptor, c as createAxiosInterceptors, h as createQueryFn, g as createSWRFetcher, _ as default, j as jQuerySetupSnippet, s as setupJQueryAjax } from './integrations-7WeFO1Lk.mjs';

package/dist/integrations.d.ts

@@ -0,0 +1 @@
+export { d as angularInterceptorSnippet, f as angularJSInterceptorSnippet, a as axiosInterceptors, b as createAngularInterceptor, e as createAngularJSInterceptor, c as createAxiosInterceptors, h as createQueryFn, g as createSWRFetcher, _ as default, j as jQuerySetupSnippet, s as setupJQueryAjax } from './integrations-7WeFO1Lk.js';

package/dist/integrations.js

@@ -0,0 +1,381 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: 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 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 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/integrations.ts
+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.angularInterceptorSnippet = angularInterceptorSnippet;
+exports.angularJSInterceptorSnippet = angularJSInterceptorSnippet;
+exports.axiosInterceptors = axiosInterceptors;
+exports.createAngularInterceptor = createAngularInterceptor;
+exports.createAngularJSInterceptor = createAngularJSInterceptor;
+exports.createAxiosInterceptors = createAxiosInterceptors;
+exports.createQueryFn = createQueryFn;
+exports.createSWRFetcher = createSWRFetcher;
+exports.default = integrations_default;
+exports.jQuerySetupSnippet = jQuerySetupSnippet;
+exports.setupJQueryAjax = setupJQueryAjax;
+//# sourceMappingURL=integrations.js.map
+//# sourceMappingURL=integrations.js.map