@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/aws-lambda/handler.js

@@ -0,0 +1,364 @@
+// src/adapter/aws-lambda/handler.ts
+import { decodeBase64, encodeBase64 } from "../../utils/encode.js";
+function sanitizeHeaderValue(value) {
+  const hasNonAscii = /[^\x00-\x7F]/.test(value);
+  if (!hasNonAscii) {
+    return value;
+  }
+  return encodeURIComponent(value);
+}
+var getRequestContext = (event) => {
+  return event.requestContext;
+};
+var streamToNodeStream = async (reader, writer) => {
+  let readResult = await reader.read();
+  while (!readResult.done) {
+    writer.write(readResult.value);
+    readResult = await reader.read();
+  }
+  writer.end();
+};
+var streamHandle = (app) => {
+  return awslambda.streamifyResponse(
+    async (event, responseStream, context) => {
+      const processor = getProcessor(event);
+      try {
+        const req = processor.createRequest(event);
+        const requestContext = getRequestContext(event);
+        const res = await app.fetch(req, {
+          event,
+          requestContext,
+          context
+        });
+        const headers = {};
+        const cookies = [];
+        res.headers.forEach((value, name) => {
+          if (name === "set-cookie") {
+            cookies.push(value);
+          } else {
+            headers[name] = value;
+          }
+        });
+        const httpResponseMetadata = {
+          statusCode: res.status,
+          headers,
+          cookies
+        };
+        responseStream = awslambda.HttpResponseStream.from(responseStream, httpResponseMetadata);
+        if (res.body) {
+          await streamToNodeStream(res.body.getReader(), responseStream);
+        } else {
+          responseStream.write("");
+        }
+      } catch (error) {
+        console.error("Error processing request:", error);
+        responseStream.write("Internal Server Error");
+      } finally {
+        responseStream.end();
+      }
+    }
+  );
+};
+var handle = (app, { isContentTypeBinary } = { isContentTypeBinary: void 0 }) => {
+  return async (event, lambdaContext) => {
+    const processor = getProcessor(event);
+    let req, requestContext;
+    try {
+      req = processor.createRequest(event);
+      requestContext = getRequestContext(event);
+    } catch (error) {
+      console.error("Error processing request:", error);
+      const errorResponse = error instanceof TypeError ? new Response("Invalid request", { status: 400 }) : new Response("Internal Server Error", { status: 500 });
+      return processor.createResult(event, errorResponse, { isContentTypeBinary });
+    }
+    const res = await app.fetch(req, {
+      event,
+      requestContext,
+      lambdaContext
+    });
+    return processor.createResult(event, res, { isContentTypeBinary });
+  };
+};
+var EventProcessor = class {
+  getHeaderValue(headers, key) {
+    const value = headers ? Array.isArray(headers[key]) ? headers[key][0] : headers[key] : void 0;
+    return value;
+  }
+  getDomainName(event) {
+    if (event.requestContext && "domainName" in event.requestContext) {
+      return event.requestContext.domainName;
+    }
+    const hostFromHeaders = this.getHeaderValue(event.headers, "host");
+    if (hostFromHeaders) {
+      return hostFromHeaders;
+    }
+    const multiValueHeaders = "multiValueHeaders" in event ? event.multiValueHeaders : {};
+    const hostFromMultiValueHeaders = this.getHeaderValue(multiValueHeaders, "host");
+    return hostFromMultiValueHeaders;
+  }
+  createRequest(event) {
+    const queryString = this.getQueryString(event);
+    const domainName = this.getDomainName(event);
+    const path = this.getPath(event);
+    const urlPath = `https://${domainName}${path}`;
+    const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+    const headers = this.getHeaders(event);
+    const method = this.getMethod(event);
+    const requestInit = {
+      headers,
+      method
+    };
+    if (event.body) {
+      const body = event.isBase64Encoded ? decodeBase64(event.body) : new TextEncoder().encode(event.body);
+      requestInit.body = body;
+      headers.set("content-length", body.length.toString());
+    }
+    return new Request(url, requestInit);
+  }
+  async createResult(event, res, options) {
+    const contentType = res.headers.get("content-type");
+    const isContentTypeBinary = options.isContentTypeBinary ?? defaultIsContentTypeBinary;
+    let isBase64Encoded = contentType && isContentTypeBinary(contentType) ? true : false;
+    if (!isBase64Encoded) {
+      const contentEncoding = res.headers.get("content-encoding");
+      isBase64Encoded = isContentEncodingBinary(contentEncoding);
+    }
+    const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
+    const result = {
+      body,
+      statusCode: res.status,
+      isBase64Encoded,
+      ..."multiValueHeaders" in event && event.multiValueHeaders ? {
+        multiValueHeaders: {}
+      } : {
+        headers: {}
+      }
+    };
+    this.setCookies(event, res, result);
+    if (result.multiValueHeaders) {
+      res.headers.forEach((value, key) => {
+        result.multiValueHeaders[key] = [value];
+      });
+    } else {
+      res.headers.forEach((value, key) => {
+        result.headers[key] = value;
+      });
+    }
+    return result;
+  }
+  setCookies(_event, res, result) {
+    if (res.headers.has("set-cookie")) {
+      const cookies = res.headers.getSetCookie ? res.headers.getSetCookie() : Array.from(res.headers.entries()).filter(([k]) => k === "set-cookie").map(([, v]) => v);
+      if (Array.isArray(cookies)) {
+        this.setCookiesToResult(result, cookies);
+        res.headers.delete("set-cookie");
+      }
+    }
+  }
+};
+var EventV2Processor = class extends EventProcessor {
+  getPath(event) {
+    return event.rawPath;
+  }
+  getMethod(event) {
+    return event.requestContext.http.method;
+  }
+  getQueryString(event) {
+    return event.rawQueryString;
+  }
+  getCookies(event, headers) {
+    if (Array.isArray(event.cookies)) {
+      headers.set("Cookie", event.cookies.join("; "));
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    result.cookies = cookies;
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, v);
+        }
+      }
+    }
+    return headers;
+  }
+};
+var v2Processor = new EventV2Processor();
+var EventV1Processor = class extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(
+        ([key, values]) => values.map((value) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&")
+      ).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value || "")}`).join("&");
+    }
+  }
+  getCookies(_event, _headers) {
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.multiValueHeaders) {
+      for (const [k, values] of Object.entries(event.multiValueHeaders)) {
+        if (values) {
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+        }
+      }
+    }
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v && !headers.has(k)) {
+          headers.set(k, sanitizeHeaderValue(v));
+        }
+      }
+    }
+    return headers;
+  }
+  setCookiesToResult(result, cookies) {
+    result.multiValueHeaders = {
+      "set-cookie": cookies
+    };
+  }
+};
+var v1Processor = new EventV1Processor();
+var ALBProcessor = class extends EventProcessor {
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.multiValueHeaders) {
+      for (const [key, values] of Object.entries(event.multiValueHeaders)) {
+        if (values && Array.isArray(values)) {
+          const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+          headers.set(key, sanitizedValue);
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(event.headers ?? {})) {
+        if (value) {
+          headers.set(key, sanitizeHeaderValue(value));
+        }
+      }
+    }
+    return headers;
+  }
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+    }
+  }
+  getCookies(event, headers) {
+    let cookie;
+    if (event.multiValueHeaders) {
+      cookie = event.multiValueHeaders["cookie"]?.join("; ");
+    } else {
+      cookie = event.headers ? event.headers["cookie"] : void 0;
+    }
+    if (cookie) {
+      headers.append("Cookie", cookie);
+    }
+  }
+  setCookiesToResult(result, cookies) {
+    if (result.multiValueHeaders) {
+      result.multiValueHeaders["set-cookie"] = cookies;
+    } else {
+      result.headers["set-cookie"] = cookies[0];
+    }
+  }
+};
+var albProcessor = new ALBProcessor();
+var LatticeV2Processor = class extends EventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.method;
+  }
+  getQueryString() {
+    return "";
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.headers) {
+      for (const [k, values] of Object.entries(event.headers)) {
+        if (values) {
+          values.forEach((v) => headers.append(k, sanitizeHeaderValue(v)));
+        }
+      }
+    }
+    return headers;
+  }
+  getCookies() {
+  }
+  setCookiesToResult(result, cookies) {
+    result.headers = {
+      ...result.headers,
+      "set-cookie": cookies
+    };
+  }
+};
+var latticeV2Processor = new LatticeV2Processor();
+var getProcessor = (event) => {
+  if (isProxyEventALB(event)) {
+    return albProcessor;
+  }
+  if (isProxyEventV2(event)) {
+    return v2Processor;
+  }
+  if (isLatticeEventV2(event)) {
+    return latticeV2Processor;
+  }
+  return v1Processor;
+};
+var isProxyEventALB = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "elb");
+  }
+  return false;
+};
+var isProxyEventV2 = (event) => {
+  return Object.hasOwn(event, "rawPath") && Object.hasOwn(event.requestContext ?? {}, "http");
+};
+var isLatticeEventV2 = (event) => {
+  if (event.requestContext) {
+    return Object.hasOwn(event.requestContext, "serviceArn");
+  }
+  return false;
+};
+var defaultIsContentTypeBinary = (contentType) => {
+  return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/.test(
+    contentType
+  );
+};
+var isContentEncodingBinary = (contentEncoding) => {
+  return !!contentEncoding && !/^identity$/i.test(contentEncoding);
+};
+export {
+  ALBProcessor,
+  EventProcessor,
+  EventV1Processor,
+  EventV2Processor,
+  LatticeV2Processor,
+  defaultIsContentTypeBinary,
+  getProcessor,
+  handle,
+  isContentEncodingBinary,
+  streamHandle
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/aws-lambda/index.js

@@ -0,0 +1,9 @@
+// src/adapter/aws-lambda/index.ts
+import { handle, streamHandle, defaultIsContentTypeBinary } from "./handler.js";
+import { getConnInfo } from "./conninfo.js";
+export {
+  defaultIsContentTypeBinary,
+  getConnInfo,
+  handle,
+  streamHandle
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/conninfo.js

@@ -0,0 +1,27 @@
+// src/adapter/bun/conninfo.ts
+import { getBunServer } from "./server.js";
+var getConnInfo = (c) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  if (typeof server.requestIP !== "function") {
+    throw new TypeError("server.requestIP is not a function.");
+  }
+  const info = server.requestIP(c.req.raw);
+  if (!info) {
+    return {
+      remote: {}
+    };
+  }
+  return {
+    remote: {
+      address: info.address,
+      addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+      port: info.port
+    }
+  };
+};
+export {
+  getConnInfo
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/index.js

@@ -0,0 +1,16 @@
+// src/adapter/bun/index.ts
+import { serveStatic } from "./serve-static.js";
+import { bunFileSystemModule, toSSG } from "./ssg.js";
+import { createBunWebSocket, upgradeWebSocket, websocket } from "./websocket.js";
+import { getConnInfo } from "./conninfo.js";
+import { getBunServer } from "./server.js";
+export {
+  bunFileSystemModule,
+  createBunWebSocket,
+  getBunServer,
+  getConnInfo,
+  serveStatic,
+  toSSG,
+  upgradeWebSocket,
+  websocket
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/serve-static.js

@@ -0,0 +1,30 @@
+// src/adapter/bun/serve-static.ts
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
+var serveStatic = (options = {}) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await stat(path);
+        isDir2 = stats.isDirectory();
+      } catch {
+      }
+      return isDir2;
+    };
+    return baseServeStatic({
+      ...options,
+      getContent,
+      join,
+      isDir
+    })(c, next);
+  };
+};
+export {
+  serveStatic
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/server.js

@@ -0,0 +1,5 @@
+// src/adapter/bun/server.ts
+var getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+export {
+  getBunServer
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/ssg.js

@@ -0,0 +1,17 @@
+// src/adapter/bun/ssg.ts
+import { toSSG as baseToSSG } from "../../helper/ssg/index.js";
+var { write } = Bun;
+var bunFileSystemModule = {
+  writeFile: async (path, data) => {
+    await write(path, data);
+  },
+  mkdir: async () => {
+  }
+};
+var toSSG = async (app, options) => {
+  return baseToSSG(app, bunFileSystemModule, options);
+};
+export {
+  bunFileSystemModule,
+  toSSG
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/bun/websocket.js

@@ -0,0 +1,73 @@
+// src/adapter/bun/websocket.ts
+import { createWSMessageEvent, defineWebSocketHelper, WSContext } from "../../helper/websocket/index.js";
+import { getBunServer } from "./server.js";
+var createWSContext = (ws) => {
+  return new WSContext({
+    send: (source, options) => {
+      ws.send(source, options?.compress);
+    },
+    raw: ws,
+    readyState: ws.readyState,
+    url: ws.data.url,
+    protocol: ws.data.protocol,
+    close(code, reason) {
+      ws.close(code, reason);
+    }
+  });
+};
+var upgradeWebSocket = defineWebSocketHelper((c, events) => {
+  const server = getBunServer(c);
+  if (!server) {
+    throw new TypeError("env has to include the 2nd argument of fetch.");
+  }
+  const upgradeResult = server.upgrade(c.req.raw, {
+    data: {
+      events,
+      url: new URL(c.req.url),
+      // The first requested subprotocol, exposed via WSContext.protocol to
+      // match the deno and cloudflare adapters.
+      protocol: c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim() ?? ""
+    }
+  });
+  if (upgradeResult) {
+    return new Response(null);
+  }
+  return;
+});
+var websocket = {
+  open(ws) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onOpen) {
+      websocketListeners.onOpen(new Event("open"), createWSContext(ws));
+    }
+  },
+  close(ws, code, reason) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onClose) {
+      websocketListeners.onClose(
+        new CloseEvent("close", {
+          code,
+          reason
+        }),
+        createWSContext(ws)
+      );
+    }
+  },
+  message(ws, message) {
+    const websocketListeners = ws.data.events;
+    if (websocketListeners.onMessage) {
+      const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
+      websocketListeners.onMessage(createWSMessageEvent(normalizedReceiveData), createWSContext(ws));
+    }
+  }
+};
+var createBunWebSocket = () => ({
+  upgradeWebSocket,
+  websocket
+});
+export {
+  createBunWebSocket,
+  createWSContext,
+  upgradeWebSocket,
+  websocket
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-pages/conninfo.js

@@ -0,0 +1,9 @@
+// src/adapter/cloudflare-pages/conninfo.ts
+var getConnInfo = (c) => ({
+  remote: {
+    address: c.req.header("cf-connecting-ip")
+  }
+});
+export {
+  getConnInfo
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-pages/handler.js

@@ -0,0 +1,67 @@
+// src/adapter/cloudflare-pages/handler.ts
+import { Context } from "../../context.js";
+import { HTTPException } from "../../http-exception.js";
+var handle = (app) => (eventContext) => {
+  return app.fetch(
+    eventContext.request,
+    { ...eventContext.env, eventContext },
+    {
+      waitUntil: eventContext.waitUntil,
+      passThroughOnException: eventContext.passThroughOnException,
+      props: {}
+    }
+  );
+};
+function handleMiddleware(middleware) {
+  return async (executionCtx) => {
+    const context = new Context(executionCtx.request, {
+      env: { ...executionCtx.env, eventContext: executionCtx },
+      executionCtx
+    });
+    let response = void 0;
+    try {
+      response = await middleware(context, async () => {
+        try {
+          context.res = await executionCtx.next();
+        } catch (error) {
+          if (error instanceof Error) {
+            context.error = error;
+          } else {
+            throw error;
+          }
+        }
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        context.error = error;
+      } else {
+        throw error;
+      }
+    }
+    if (response) {
+      return response;
+    }
+    if (context.error instanceof HTTPException) {
+      return context.error.getResponse();
+    }
+    if (context.error) {
+      throw context.error;
+    }
+    return context.res;
+  };
+}
+var serveStatic = () => {
+  return async (c) => {
+    const env = c.env;
+    const res = await env.ASSETS.fetch(c.req.raw);
+    if (res.status === 404) {
+      return c.notFound();
+    }
+    return res;
+  };
+};
+export {
+  handle,
+  handleMiddleware,
+  serveStatic
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-pages/index.js

@@ -0,0 +1,9 @@
+// src/adapter/cloudflare-pages/index.ts
+import { handle, handleMiddleware, serveStatic } from "./handler.js";
+import { getConnInfo } from "./conninfo.js";
+export {
+  getConnInfo,
+  handle,
+  handleMiddleware,
+  serveStatic
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-workers/conninfo.js

@@ -0,0 +1,9 @@
+// src/adapter/cloudflare-workers/conninfo.ts
+var getConnInfo = (c) => ({
+  remote: {
+    address: c.req.header("cf-connecting-ip")
+  }
+});
+export {
+  getConnInfo
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-workers/index.js

@@ -0,0 +1,9 @@
+// src/adapter/cloudflare-workers/index.ts
+import { serveStatic } from "./serve-static-module.js";
+import { upgradeWebSocket } from "./websocket.js";
+import { getConnInfo } from "./conninfo.js";
+export {
+  getConnInfo,
+  serveStatic,
+  upgradeWebSocket
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-workers/serve-static-module.js

@@ -0,0 +1,8 @@
+// src/adapter/cloudflare-workers/serve-static-module.ts
+import { serveStatic } from "./serve-static.js";
+var module = (options) => {
+  return serveStatic(options);
+};
+export {
+  module as serveStatic
+};

package/node_modules/@zuplo/editor/node_modules/hono/dist/adapter/cloudflare-workers/serve-static.js

@@ -0,0 +1,22 @@
+// src/adapter/cloudflare-workers/serve-static.ts
+import { serveStatic as baseServeStatic } from "../../middleware/serve-static/index.js";
+import { getContentFromKVAsset } from "./utils.js";
+var serveStatic = (options = {}) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      return getContentFromKVAsset(path, {
+        manifest: options.manifest,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : void 0
+      });
+    };
+    return baseServeStatic({
+      ...options,
+      getContent
+    })(c, next);
+  };
+};
+export {
+  serveStatic
+};