gomtm 0.0.1 → 0.0.3

package/dist/esm/connectquery/use-query.js

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import {
+  useQuery as tsUseQuery,
+  useSuspenseQuery as tsUseSuspenseQuery
+} from "@tanstack/react-query";
+import { createUseQueryOptions } from "./create-use-query-options";
+import { useTransport } from "./use-transport";
+function useQuery(methodSig, input, _a = {}) {
+  var _b = _a, {
+    transport,
+    callOptions
+  } = _b, queryOptions = __objRest(_b, [
+    "transport",
+    "callOptions"
+  ]);
+  var _a2;
+  const transportFromCtx = useTransport();
+  const baseOptions = createUseQueryOptions(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    callOptions
+  });
+  const enabled = baseOptions.enabled && ((_a2 = queryOptions.enabled) != null ? _a2 : true);
+  return tsUseQuery(__spreadProps(__spreadValues(__spreadValues({}, queryOptions), baseOptions), {
+    enabled
+  }));
+}
+function useSuspenseQuery(methodSig, input, _c = {}) {
+  var _d = _c, {
+    transport,
+    callOptions
+  } = _d, queryOptions = __objRest(_d, [
+    "transport",
+    "callOptions"
+  ]);
+  const transportFromCtx = useTransport();
+  const baseOptions = createUseQueryOptions(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    callOptions
+  });
+  return tsUseSuspenseQuery(__spreadValues(__spreadValues({}, queryOptions), baseOptions));
+}
+export {
+  useQuery,
+  useSuspenseQuery
+};

package/dist/esm/connectquery/use-transport.d.ts

@@ -0,0 +1,7 @@
+import type { Transport } from "@connectrpc/connect";
+import type { FC, PropsWithChildren } from "react";
+export declare const fallbackTransport: Transport;
+export declare const useTransport: () => Transport;
+export declare const TransportProvider: FC<PropsWithChildren<{
+    transport: Transport;
+}>>;

package/dist/esm/connectquery/use-transport.js

@@ -0,0 +1,23 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { ConnectError } from "@connectrpc/connect";
+import { createContext, useContext } from "react";
+const fallbackTransportError = new ConnectError(
+  "To use Connect, you must provide a `Transport`: a simple object that handles `unary` and `stream` requests. `Transport` objects can easily be created by using `@connectrpc/connect-web`'s exports `createConnectTransport` and `createGrpcWebTransport`. see: https://connectrpc.com/docs/web/getting-started for more info."
+);
+const fallbackTransport = {
+  unary: () => {
+    throw fallbackTransportError;
+  },
+  stream: () => {
+    throw fallbackTransportError;
+  }
+};
+const transportContext = createContext(fallbackTransport);
+const useTransport = () => useContext(transportContext);
+const TransportProvider = ({ children, transport }) => /* @__PURE__ */ jsx(transportContext.Provider, { value: transport, children });
+export {
+  TransportProvider,
+  fallbackTransport,
+  useTransport
+};

package/dist/esm/connectquery/utils.d.ts

@@ -0,0 +1,12 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+export interface MtUnaryCallError {
+    error_code: string;
+    error_message?: string;
+}
+export declare const disableQuery: unique symbol;
+export type DisableQuery = typeof disableQuery;
+export declare function assert(condition: boolean, message: string): asserts condition;
+export declare const isAbortController: (input: unknown) => input is AbortController;
+export type ConnectUpdater<O extends Message<O>> = PartialMessage<O> | ((prev?: O) => PartialMessage<O> | undefined);
+export declare const createProtobufSafeUpdater: <I extends Message<I>, O extends Message<O>>(methodSig: Pick<MethodUnaryDescriptor<I, O>, "O">, updater: ConnectUpdater<O>) => (prev?: O) => O;

package/dist/esm/connectquery/utils.js

@@ -0,0 +1,24 @@
+const disableQuery = Symbol("disableQuery");
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Invalid assertion: ${message}`);
+  }
+}
+const isAbortController = (input) => {
+  if (typeof input === "object" && input !== null && "signal" in input && typeof input.signal === "object" && input.signal !== null && "aborted" in input.signal && typeof input.signal.aborted === "boolean" && "abort" in input && typeof input.abort === "function") {
+    return true;
+  }
+  return false;
+};
+const createProtobufSafeUpdater = (methodSig, updater) => (prev) => {
+  if (typeof updater === "function") {
+    return new methodSig.O(updater(prev));
+  }
+  return new methodSig.O(updater);
+};
+export {
+  assert,
+  createProtobufSafeUpdater,
+  disableQuery,
+  isAbortController
+};

package/dist/esm/consts.d.ts

@@ -0,0 +1,28 @@
+export declare const COOKIE_MTM_SITE_ID = "mtm-site-id";
+export declare const COOKIE_IS_DEBUG = "DEBUG";
+export declare const MTM_SITE_HOSTNAME = "mtm-site-hostname";
+export declare const MtM_TOKEN_NAME = "mtm_token33";
+export declare const fetchMaxRetry = 3;
+export declare const HeaderMtmHost = "Mtm-Host";
+export declare const HeaderMtmApi = "Mtm-Api";
+export declare const Cookie_Site_Host = "site-host";
+export declare const MTM_SERVER_COOKIE_ACTIVATE_URL = "mtm:serverUrl";
+export declare const MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL = "mtm:selfbackendUrl";
+export declare const DEFAULT_revalidate_SECONDS = 3;
+export declare const LOGIN_CALLBACK_URL_KEY = "back";
+export declare const ExtKey_Hostname = "host";
+export declare const ExtKey_mtmaccessToken = "access_token";
+export declare const ExtKey_mtmbackend = "mtmbackend";
+export declare const ExtKey_SelfBackend = "selfbackend";
+export declare const ItemAction_list_new_item = "list_new_item";
+export declare const Listview_list_filter = "Listview_list_filter";
+export declare const ActionEdit = "edit";
+export declare const ActionDelete = "delete";
+export declare const ActionCreate = "create";
+export declare const ActionFetchNextPage = "fetchNextPage";
+export declare const ActionRefetch = "refetch";
+export declare const ListView_DefaultPageSize = 12;
+export declare const ImageNoExist = "/images/404.jpg";
+export declare const ADMIN_ROLE = "admin";
+export declare const MEMBER_ROLE = "member";
+export declare const TRPC_API_PREFIX = "/api.v1/trpc";

package/dist/esm/consts.js

@@ -0,0 +1,58 @@
+const COOKIE_MTM_SITE_ID = "mtm-site-id";
+const COOKIE_IS_DEBUG = "DEBUG";
+const MTM_SITE_HOSTNAME = "mtm-site-hostname";
+const MtM_TOKEN_NAME = "mtm_token33";
+const fetchMaxRetry = 3;
+const HeaderMtmHost = "Mtm-Host";
+const HeaderMtmApi = "Mtm-Api";
+const Cookie_Site_Host = "site-host";
+const MTM_SERVER_COOKIE_ACTIVATE_URL = "mtm:serverUrl";
+const MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL = "mtm:selfbackendUrl";
+const DEFAULT_revalidate_SECONDS = 3;
+const LOGIN_CALLBACK_URL_KEY = "back";
+const ExtKey_Hostname = "host";
+const ExtKey_mtmaccessToken = "access_token";
+const ExtKey_mtmbackend = "mtmbackend";
+const ExtKey_SelfBackend = "selfbackend";
+const ItemAction_list_new_item = "list_new_item";
+const Listview_list_filter = "Listview_list_filter";
+const ActionEdit = "edit";
+const ActionDelete = "delete";
+const ActionCreate = "create";
+const ActionFetchNextPage = "fetchNextPage";
+const ActionRefetch = "refetch";
+const ListView_DefaultPageSize = 12;
+const ImageNoExist = "/images/404.jpg";
+const ADMIN_ROLE = "admin";
+const MEMBER_ROLE = "member";
+const TRPC_API_PREFIX = "/api.v1/trpc";
+export {
+  ADMIN_ROLE,
+  ActionCreate,
+  ActionDelete,
+  ActionEdit,
+  ActionFetchNextPage,
+  ActionRefetch,
+  COOKIE_IS_DEBUG,
+  COOKIE_MTM_SITE_ID,
+  Cookie_Site_Host,
+  DEFAULT_revalidate_SECONDS,
+  ExtKey_Hostname,
+  ExtKey_SelfBackend,
+  ExtKey_mtmaccessToken,
+  ExtKey_mtmbackend,
+  HeaderMtmApi,
+  HeaderMtmHost,
+  ImageNoExist,
+  ItemAction_list_new_item,
+  LOGIN_CALLBACK_URL_KEY,
+  ListView_DefaultPageSize,
+  Listview_list_filter,
+  MEMBER_ROLE,
+  MTM_SERVER_COOKIE_ACTIVATE_SELFBACKEND_URL,
+  MTM_SERVER_COOKIE_ACTIVATE_URL,
+  MTM_SITE_HOSTNAME,
+  MtM_TOKEN_NAME,
+  TRPC_API_PREFIX,
+  fetchMaxRetry
+};

package/dist/esm/http/cors.d.ts

@@ -0,0 +1,15 @@
+type StaticOrigin = boolean | string | RegExp | (boolean | string | RegExp)[];
+type OriginFn = (origin: string | undefined, req: Request) => StaticOrigin | Promise<StaticOrigin>;
+interface CorsOptions {
+    origin?: StaticOrigin | OriginFn;
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}
+export default function cors(req: Request, res: Response, options?: CorsOptions): Promise<Response>;
+export declare function initCors(options?: CorsOptions): (req: Request, res: Response) => Promise<Response>;
+export {};

package/dist/esm/http/cors.js

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const defaultOptions = {
+  origin: "*",
+  methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+  preflightContinue: false,
+  optionsSuccessStatus: 204
+};
+function isOriginAllowed(origin, allowed) {
+  return Array.isArray(allowed) ? allowed.some((o) => isOriginAllowed(origin, o)) : typeof allowed === "string" ? origin === allowed : allowed instanceof RegExp ? allowed.test(origin) : !!allowed;
+}
+function getOriginHeaders(reqOrigin, origin) {
+  const headers = new Headers();
+  if (origin === "*") {
+    headers.set("Access-Control-Allow-Origin", "*");
+  } else if (typeof origin === "string") {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.append("Vary", "Origin");
+  } else {
+    const allowed = isOriginAllowed(reqOrigin != null ? reqOrigin : "", origin);
+    if (allowed && reqOrigin) {
+      headers.set("Access-Control-Allow-Origin", reqOrigin);
+    }
+    headers.append("Vary", "Origin");
+  }
+  return headers;
+}
+function originHeadersFromReq(req, origin) {
+  return __async(this, null, function* () {
+    const reqOrigin = req.headers.get("Origin") || void 0;
+    const value = typeof origin === "function" ? yield origin(reqOrigin, req) : origin;
+    if (!value)
+      return;
+    return getOriginHeaders(reqOrigin, value);
+  });
+}
+function getAllowedHeaders(req, allowed) {
+  const headers = new Headers();
+  if (!allowed) {
+    allowed = req.headers.get("Access-Control-Request-Headers");
+    headers.append("Vary", "Access-Control-Request-Headers");
+  } else if (Array.isArray(allowed)) {
+    allowed = allowed.join(",");
+  }
+  if (allowed) {
+    headers.set("Access-Control-Allow-Headers", allowed);
+  }
+  return headers;
+}
+function cors(req, res, options) {
+  return __async(this, null, function* () {
+    var _a;
+    const opts = __spreadValues(__spreadValues({}, defaultOptions), options);
+    const { headers } = res;
+    const originHeaders = yield originHeadersFromReq(req, (_a = opts.origin) != null ? _a : false);
+    const mergeHeaders = (v, k) => {
+      if (k === "Vary")
+        headers.append(k, v);
+      else
+        headers.set(k, v);
+    };
+    if (!originHeaders)
+      return res;
+    originHeaders.forEach(mergeHeaders);
+    if (opts.credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    const exposed = Array.isArray(opts.exposedHeaders) ? opts.exposedHeaders.join(",") : opts.exposedHeaders;
+    if (exposed) {
+      headers.set("Access-Control-Expose-Headers", exposed);
+    }
+    if (req.method === "OPTIONS") {
+      if (opts.methods) {
+        const methods = Array.isArray(opts.methods) ? opts.methods.join(",") : opts.methods;
+        headers.set("Access-Control-Allow-Methods", methods);
+      }
+      getAllowedHeaders(req, opts.allowedHeaders).forEach(mergeHeaders);
+      if (typeof opts.maxAge === "number") {
+        headers.set("Access-Control-Max-Age", String(opts.maxAge));
+      }
+      if (opts.preflightContinue)
+        return res;
+      headers.set("Content-Length", "0");
+      return new Response(null, { status: opts.optionsSuccessStatus, headers });
+    }
+    return res;
+  });
+}
+function initCors(options) {
+  return (req, res) => cors(req, res, options);
+}
+export {
+  cors as default,
+  initCors
+};

package/dist/esm/http/fetchMiddleWithCache.d.ts

@@ -0,0 +1,2 @@
+import type { FetchType } from "./mthttp";
+export declare function fetchMiddleWithCache(fetcher: FetchType): (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;

package/dist/esm/http/fetchMiddleWithCache.js

@@ -0,0 +1,87 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { LRUCache } from "lru-cache";
+import { sha256WithAlphabets } from "../utils";
+const options = {
+  max: 500,
+  // for use with tracking overall storage size
+  maxSize: 5e3,
+  sizeCalculation: (value, key) => {
+    return 1;
+  },
+  // for use when you need to clean up something when objects
+  // are evicted from the cache
+  // dispose: (value, key) => {
+  //   // freeFromMemoryOrWhatever(value)
+  // },
+  ttl: 1e3 * 30,
+  // return stale items before removing from cache?
+  allowStale: false,
+  updateAgeOnGet: false,
+  updateAgeOnHas: false
+};
+const cache = new LRUCache(options);
+const makeCacheKey = (input, init) => {
+  const req = new Request(input, init);
+  const token = req.headers.get("authorization");
+  let body = "";
+  if (init == null ? void 0 : init.body) {
+    body = init.body.toString();
+  }
+  return sha256WithAlphabets(input + token + body);
+};
+function fetchMiddleWithCache(fetcher) {
+  return (input, init) => __async(this, null, function* () {
+    const key = yield makeCacheKey(input, init);
+    const cacheObj = cache.get(key);
+    if (cacheObj) {
+      return new Response(new Uint8Array(cacheObj));
+    } else {
+      const response = yield fetcher(input, init);
+      if (response.status == 200 && response.body) {
+        const [s1, s2] = response.body.tee();
+        writeStreamToCache(key, s2);
+        return new Response(s1, response);
+      }
+      return response.clone();
+    }
+  });
+}
+function writeStreamToCache(key, steam) {
+  return __async(this, null, function* () {
+    const chunks = [];
+    let done = false;
+    const s2Reader = yield steam.getReader();
+    while (!done) {
+      const { value, done: readerDone } = yield s2Reader.read();
+      done = readerDone;
+      if (value)
+        chunks.push(value);
+    }
+    const byteArray = new Uint8Array(chunks.reduce((acc, chunk) => [...acc, ...Array.from(chunk)], []));
+    if (byteArray.buffer.byteLength > 0) {
+      cache.set(key, byteArray.buffer);
+    }
+  });
+}
+export {
+  fetchMiddleWithCache
+};

package/dist/esm/http/fetchMiddleWithUrlProxy.d.ts

@@ -0,0 +1,2 @@
+import type { FetchType } from "./mthttp";
+export declare function fetchMiddleWithUrlProxy(fetcher: FetchType): (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<Response>;

package/dist/esm/http/fetchMiddleWithUrlProxy.js

@@ -0,0 +1,28 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function fetchMiddleWithUrlProxy(fetcher) {
+  return (input, init) => __async(this, null, function* () {
+    return fetcher(input, init);
+  });
+}
+export {
+  fetchMiddleWithUrlProxy
+};

package/dist/esm/http/mthttp.d.ts

@@ -0,0 +1,5 @@
+export type FetchType = typeof fetch;
+export declare const responseJson: (data: any) => Response;
+export declare function jsonResponse(data: any): Promise<Response>;
+export declare function jsonSuccessResponse(data?: any): Promise<Response>;
+export declare function getContentType(req: Request): string | null;

package/dist/esm/http/mthttp.js

@@ -0,0 +1,61 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const responseJson = (data) => {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: {
+      "Content-type": "application/json"
+    }
+  });
+};
+function jsonResponse(data) {
+  return __async(this, null, function* () {
+    try {
+      return new Response(JSON.stringify(data), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (e) {
+      console.log(e);
+      return new Response(JSON.stringify({ error: e.message }));
+    }
+  });
+}
+function jsonSuccessResponse(data) {
+  return __async(this, null, function* () {
+    return jsonResponse({
+      success: true,
+      data
+    });
+  });
+}
+function getContentType(req) {
+  const a = req.headers.get("Content-Type");
+  return a;
+}
+export {
+  getContentType,
+  jsonResponse,
+  jsonSuccessResponse,
+  responseJson
+};

package/dist/esm/http/response-cache.test.js

@@ -0,0 +1,72 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { fetchMiddleWithCache } from "./fetchMiddleWithCache";
+test("fetch \u7F13\u5B58\u6B63\u5E38\u60C5\u51B5", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  const count = 10;
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(new Response("abc", {})));
+    const res = yield fetchWithCache("https://www.bing.com", {
+      headers: {
+        authorization: "token2"
+      }
+    });
+    const content = yield res.text();
+    expect(content).toContain("abc");
+  }
+  expect(fetchFn.mock.calls.length).toBe(1);
+}));
+test("fetch \u975E200\u54CD\u5E94\u4E0D\u505A\u7F13\u5B58", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  const count = 10;
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(
+      new Response("some content", {
+        status: 500
+      })
+    ));
+    const res = yield fetchWithCache("https://www.bing.com", {
+      headers: {
+        authorization: "token1"
+      }
+    });
+    const content = yield res.text();
+    expect(content).toContain("some conten");
+  }
+  expect(fetchFn.mock.calls.length).toBe(count);
+}));
+test("fetch \u7F13\u5B58\u4E0D\u540C\u7684url", () => __async(void 0, null, function* () {
+  const fetchFn = jest.fn(fetch);
+  const count = 10;
+  const fetchWithCache = fetchMiddleWithCache(fetchFn);
+  for (let i = 0; i < count; i++) {
+    fetchFn.mockReturnValueOnce(Promise.resolve(new Response("abc", {})));
+    const res = yield fetchWithCache(`https://www.bing.com/${i}`, {
+      headers: {
+        authorization: "token2"
+      }
+    });
+    expect(yield res.text()).toContain("abc");
+  }
+  expect(fetchFn.mock.calls.length).toBe(10);
+}));

package/dist/esm/messageTypeRegistry.d.ts

@@ -0,0 +1,4 @@
+import { IMessageTypeRegistry, ServiceType } from "@bufbuild/protobuf";
+export declare const anypbTypeReg: IMessageTypeRegistry;
+export declare const allServices: Record<string, ServiceType>;
+export declare const GetMtmServiceByTypeName: (serviceTypeName: string) => ServiceType;