@trpc/server 11.0.0-next-beta.206 → 11.0.0-next-beta.216

package/dist/node_modules/.pnpm/@web3-storage_multipart-parser@1.0.0/node_modules/@web3-storage/multipart-parser/esm/src/search.mjs

@@ -0,0 +1,163 @@
+import { stringToArray } from './utils.mjs';
+
+function coerce(a) {
+  if (a instanceof Uint8Array) {
+    return index => a[index];
+  }
+  return a;
+}
+function jsmemcmp(buf1, pos1, buf2, pos2, len) {
+  const fn1 = coerce(buf1);
+  const fn2 = coerce(buf2);
+  for (let i = 0; i < len; ++i) {
+    if (fn1(pos1 + i) !== fn2(pos2 + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createOccurenceTable(s) {
+  const table = new Array(256).fill(s.length);
+  if (s.length > 1) {
+    for (let i = 0; i < s.length - 1; i++) {
+      table[s[i]] = s.length - 1 - i;
+    }
+  }
+  return table;
+}
+const MATCH = Symbol('Match');
+class StreamSearch {
+  constructor(needle) {
+    this._lookbehind = new Uint8Array();
+    if (typeof needle === 'string') {
+      this._needle = needle = stringToArray(needle);
+    } else {
+      this._needle = needle;
+    }
+    this._lastChar = needle[needle.length - 1];
+    this._occ = createOccurenceTable(needle);
+  }
+  feed(chunk) {
+    let pos = 0;
+    let tokens;
+    const allTokens = [];
+    while (pos !== chunk.length) {
+      [pos, ...tokens] = this._feed(chunk, pos);
+      allTokens.push(...tokens);
+    }
+    return allTokens;
+  }
+  end() {
+    const tail = this._lookbehind;
+    this._lookbehind = new Uint8Array();
+    return tail;
+  }
+  _feed(data, bufPos) {
+    const tokens = [];
+    let pos = -this._lookbehind.length;
+    if (pos < 0) {
+      while (pos < 0 && pos <= data.length - this._needle.length) {
+        const ch = this._charAt(data, pos + this._needle.length - 1);
+        if (ch === this._lastChar && this._memcmp(data, pos, this._needle.length - 1)) {
+          if (pos > -this._lookbehind.length) {
+            tokens.push(this._lookbehind.slice(0, this._lookbehind.length + pos));
+          }
+          tokens.push(MATCH);
+          this._lookbehind = new Uint8Array();
+          return [
+            pos + this._needle.length,
+            ...tokens
+          ];
+        } else {
+          pos += this._occ[ch];
+        }
+      }
+      if (pos < 0) {
+        while (pos < 0 && !this._memcmp(data, pos, data.length - pos)) {
+          pos++;
+        }
+      }
+      if (pos >= 0) {
+        tokens.push(this._lookbehind);
+        this._lookbehind = new Uint8Array();
+      } else {
+        const bytesToCutOff = this._lookbehind.length + pos;
+        if (bytesToCutOff > 0) {
+          tokens.push(this._lookbehind.slice(0, bytesToCutOff));
+          this._lookbehind = this._lookbehind.slice(bytesToCutOff);
+        }
+        this._lookbehind = Uint8Array.from(new Array(this._lookbehind.length + data.length), (_, i) => this._charAt(data, i - this._lookbehind.length));
+        return [
+          data.length,
+          ...tokens
+        ];
+      }
+    }
+    pos += bufPos;
+    while (pos <= data.length - this._needle.length) {
+      const ch = data[pos + this._needle.length - 1];
+      if (ch === this._lastChar && data[pos] === this._needle[0] && jsmemcmp(this._needle, 0, data, pos, this._needle.length - 1)) {
+        if (pos > bufPos) {
+          tokens.push(data.slice(bufPos, pos));
+        }
+        tokens.push(MATCH);
+        return [
+          pos + this._needle.length,
+          ...tokens
+        ];
+      } else {
+        pos += this._occ[ch];
+      }
+    }
+    if (pos < data.length) {
+      while (pos < data.length && (data[pos] !== this._needle[0] || !jsmemcmp(data, pos, this._needle, 0, data.length - pos))) {
+        ++pos;
+      }
+      if (pos < data.length) {
+        this._lookbehind = data.slice(pos);
+      }
+    }
+    if (pos > 0) {
+      tokens.push(data.slice(bufPos, pos < data.length ? pos : data.length));
+    }
+    return [
+      data.length,
+      ...tokens
+    ];
+  }
+  _charAt(data, pos) {
+    if (pos < 0) {
+      return this._lookbehind[this._lookbehind.length + pos];
+    }
+    return data[pos];
+  }
+  _memcmp(data, pos, len) {
+    return jsmemcmp(this._charAt.bind(this, data), pos, this._needle, 0, len);
+  }
+}
+class ReadableStreamSearch {
+  constructor(needle, _readableStream) {
+    this._readableStream = _readableStream;
+    this._search = new StreamSearch(needle);
+  }
+  async *[Symbol.asyncIterator]() {
+    const reader = this._readableStream.getReader();
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done) {
+          break;
+        }
+        yield* this._search.feed(result.value);
+      }
+      const tail = this._search.end();
+      if (tail.length) {
+        yield tail;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+
+export { MATCH, ReadableStreamSearch, StreamSearch };

package/dist/node_modules/.pnpm/@web3-storage_multipart-parser@1.0.0/node_modules/@web3-storage/multipart-parser/esm/src/utils.js

@@ -0,0 +1,35 @@
+'use strict';
+
+function stringToArray(s) {
+  const utf8 = unescape(encodeURIComponent(s));
+  return Uint8Array.from(utf8, (_, i) => utf8.charCodeAt(i));
+}
+function arrayToString(a) {
+  const utf8 = String.fromCharCode.apply(null, a);
+  return decodeURIComponent(escape(utf8));
+}
+function mergeArrays(...arrays) {
+  const out = new Uint8Array(arrays.reduce((total, arr) => total + arr.length, 0));
+  let offset = 0;
+  for (const arr of arrays) {
+    out.set(arr, offset);
+    offset += arr.length;
+  }
+  return out;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+exports.arrayToString = arrayToString;
+exports.arraysEqual = arraysEqual;
+exports.mergeArrays = mergeArrays;
+exports.stringToArray = stringToArray;

package/dist/node_modules/.pnpm/@web3-storage_multipart-parser@1.0.0/node_modules/@web3-storage/multipart-parser/esm/src/utils.mjs

@@ -0,0 +1,30 @@
+function stringToArray(s) {
+  const utf8 = unescape(encodeURIComponent(s));
+  return Uint8Array.from(utf8, (_, i) => utf8.charCodeAt(i));
+}
+function arrayToString(a) {
+  const utf8 = String.fromCharCode.apply(null, a);
+  return decodeURIComponent(escape(utf8));
+}
+function mergeArrays(...arrays) {
+  const out = new Uint8Array(arrays.reduce((total, arr) => total + arr.length, 0));
+  let offset = 0;
+  for (const arr of arrays) {
+    out.set(arr, offset);
+    offset += arr.length;
+  }
+  return out;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { arrayToString, arraysEqual, mergeArrays, stringToArray };

package/dist/observable.js

@@ -1,13 +1,11 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var observable = require('@trpc/core/observable');
 
 
 
 Object.keys(observable).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
 		get: function () { return observable[k]; }
 	});

package/dist/rpc.js

@@ -1,13 +1,11 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var rpc = require('@trpc/core/rpc');
 
 
 
 Object.keys(rpc).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
 		get: function () { return rpc[k]; }
 	});

package/dist/shared.js

@@ -1,16 +1,14 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@trpc/core');
 
 
 
-Object.defineProperty(exports, 'createFlatProxy', {
+Object.defineProperty(exports, "createFlatProxy", {
   enumerable: true,
   get: function () { return core.createFlatProxy; }
 });
-Object.defineProperty(exports, 'getErrorShape', {
+Object.defineProperty(exports, "getErrorShape", {
   enumerable: true,
   get: function () { return core.getErrorShape; }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-next-beta.206+255803252",
+  "version": "11.0.0-next-beta.216+ccd4f1b0e",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -115,7 +115,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@trpc/core": "11.0.0-next-beta.206+255803252"
+    "@trpc/core": "11.0.0-next-beta.216+ccd4f1b0e"
   },
   "devDependencies": {
     "@fastify/websocket": "^7.1.2",
@@ -139,7 +139,7 @@
     "next": "^14.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "rollup": "^2.79.1",
+    "rollup": "^4.9.5",
     "superjson": "^1.12.4",
     "superstruct": "^1.0.0",
     "tslib": "^2.5.0",
@@ -154,5 +154,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "2558032520acb8dc9ffe9dfe30ba94bab3f06e36"
+  "gitHead": "ccd4f1b0e0f2a11dbac63085665dfc9639a9cfb3"
 }

package/dist/contentType-24c44bba.js

@@ -1,5 +0,0 @@
-function createNodeHTTPContentTypeHandler(contentTypeHandler) {
-    return () => contentTypeHandler;
-}
-
-export { createNodeHTTPContentTypeHandler as c };

package/dist/nodeHTTPRequestHandler-aa0dce4e.js

@@ -1,105 +0,0 @@
-import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/core/http';
-import { nodeHTTPJSONContentTypeHandler } from './adapters/node-http/content-type/json/index.js';
-
-const defaultJSONContentTypeHandler = nodeHTTPJSONContentTypeHandler();
-async function nodeHTTPRequestHandler(opts) {
-    const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
-    return handleViaMiddleware(opts.req, opts.res, async (err) => {
-        if (err)
-            throw err;
-        //
-        // Build tRPC dependencies
-        const createContext = async (innerOpts) => {
-            return await opts.createContext?.({
-                ...opts,
-                ...innerOpts,
-            });
-        };
-        const query = opts.req.query
-            ? new URLSearchParams(opts.req.query)
-            : new URLSearchParams(opts.req.url.split('?')[1]);
-        const jsonContentTypeHandler = defaultJSONContentTypeHandler;
-        const contentTypeHandlers = opts.experimental_contentTypeHandlers ?? [
-            jsonContentTypeHandler,
-        ];
-        const contentTypeHandler = contentTypeHandlers.find((handler) => handler.isMatch({
-            ...opts,
-            query,
-        })) ??
-            // fallback to json
-            jsonContentTypeHandler;
-        const bodyResult = await contentTypeHandler.getBody({
-            ...opts,
-            query,
-        });
-        const req = {
-            method: opts.req.method,
-            headers: opts.req.headers,
-            query,
-            body: bodyResult.ok ? bodyResult.data : undefined,
-        };
-        let isStream = false;
-        let formatter;
-        const unstable_onHead = (head, isStreaming) => {
-            if ('status' in head &&
-                (!opts.res.statusCode || opts.res.statusCode === 200)) {
-                opts.res.statusCode = head.status;
-            }
-            for (const [key, value] of Object.entries(head.headers ?? {})) {
-                /* istanbul ignore if -- @preserve */
-                if (typeof value === 'undefined') {
-                    continue;
-                }
-                opts.res.setHeader(key, value);
-            }
-            if (isStreaming) {
-                opts.res.setHeader('Transfer-Encoding', 'chunked');
-                const vary = opts.res.getHeader('Vary');
-                opts.res.setHeader('Vary', vary ? 'trpc-batch-mode, ' + vary : 'trpc-batch-mode');
-                isStream = true;
-                formatter = getBatchStreamFormatter();
-                opts.res.flushHeaders();
-            }
-        };
-        const unstable_onChunk = ([index, string]) => {
-            if (index === -1) {
-                /**
-                 * Full response, no streaming. This can happen
-                 * - if the response is an error
-                 * - if response is empty (HEAD request)
-                 */
-                opts.res.end(string);
-            }
-            else {
-                opts.res.write(formatter(index, string));
-                opts.res.flush?.();
-            }
-        };
-        await resolveHTTPResponse({
-            batching: opts.batching,
-            responseMeta: opts.responseMeta,
-            path: opts.path,
-            createContext,
-            router: opts.router,
-            req,
-            error: bodyResult.ok ? null : bodyResult.error,
-            preprocessedBody: bodyResult.ok ? bodyResult.preprocessed : false,
-            onError(o) {
-                opts?.onError?.({
-                    ...o,
-                    req: opts.req,
-                });
-            },
-            contentTypeHandler,
-            unstable_onHead,
-            unstable_onChunk,
-        });
-        if (isStream) {
-            opts.res.write(formatter.end());
-            opts.res.end();
-        }
-        return opts.res;
-    });
-}
-
-export { nodeHTTPRequestHandler as n };