@epoch32/visage 1.1.2 → 1.1.4

package/dist/index-965ryh36.js

@@ -0,0 +1,537 @@
+import {
+  validateWithSchema2
+} from "./index-2zz0g2n2.js";
+
+// src/rpc/error.ts
+var ERROR_CODE_TO_STATUS2 = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  UNPROCESSABLE_CONTENT: 422,
+  INTERNAL_SERVER_ERROR: 500
+};
+var STATUS_TO_ERROR_CODE2 = {
+  400: "BAD_REQUEST",
+  401: "UNAUTHORIZED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  405: "METHOD_NOT_ALLOWED",
+  408: "TIMEOUT",
+  409: "CONFLICT",
+  422: "UNPROCESSABLE_CONTENT",
+  500: "INTERNAL_SERVER_ERROR"
+};
+
+class RPCError2 extends Error {
+  code;
+  status;
+  issues;
+  constructor(codeOrStatusOrOptions, message) {
+    if (typeof codeOrStatusOrOptions === "number") {
+      const code = STATUS_TO_ERROR_CODE2[codeOrStatusOrOptions] || "INTERNAL_SERVER_ERROR";
+      super(message || code);
+      this.name = "RPCError";
+      this.code = code;
+      this.status = codeOrStatusOrOptions;
+    } else if (typeof codeOrStatusOrOptions === "string") {
+      super(message || codeOrStatusOrOptions);
+      this.name = "RPCError";
+      this.code = codeOrStatusOrOptions;
+      this.status = ERROR_CODE_TO_STATUS2[codeOrStatusOrOptions] || 500;
+    } else {
+      super(codeOrStatusOrOptions.message ?? codeOrStatusOrOptions.code, {
+        cause: codeOrStatusOrOptions.cause
+      });
+      this.name = "RPCError";
+      this.code = codeOrStatusOrOptions.code;
+      this.status = ERROR_CODE_TO_STATUS2[codeOrStatusOrOptions.code] ?? 500;
+      this.issues = codeOrStatusOrOptions.issues;
+    }
+  }
+  get statusCode() {
+    return this.status;
+  }
+}
+
+// src/rpc/procedure.ts
+function createProcedure2(type, options, middlewares = []) {
+  return {
+    type,
+    inputSchema: options.input,
+    outputSchema: options.output,
+    middlewares: [...middlewares],
+    resolve: options.resolve
+  };
+}
+async function executeProcedure2(procedure, opts) {
+  let input = opts.rawInput;
+  if (procedure.inputSchema) {
+    const res = validateWithSchema2(procedure.inputSchema, opts.rawInput);
+    if (!res.success) {
+      throw new RPCError2({
+        code: "BAD_REQUEST",
+        message: "Invalid procedure input",
+        issues: res.issues
+      });
+    }
+    input = res.data;
+  }
+  let currentIndex = 0;
+  let currentContext = opts.ctx;
+  const runPipeline = async (ctx) => {
+    currentContext = ctx;
+    if (currentIndex < procedure.middlewares.length) {
+      const mw = procedure.middlewares[currentIndex++];
+      return mw({
+        ctx: currentContext,
+        req: opts.req,
+        signal: opts.signal,
+        next: async (nextOpts) => {
+          return runPipeline(nextOpts?.ctx ?? currentContext);
+        }
+      });
+    }
+    return procedure.resolve({
+      input,
+      ctx: currentContext,
+      req: opts.req,
+      signal: opts.signal
+    });
+  };
+  const output = await runPipeline(currentContext);
+  if (procedure.outputSchema && procedure.type !== "subscription") {
+    const res = validateWithSchema2(procedure.outputSchema, output);
+    if (!res.success) {
+      throw new RPCError2({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Invalid procedure output",
+        issues: res.issues
+      });
+    }
+    return res.data;
+  }
+  return output;
+}
+
+// src/rpc/server.ts
+function getCORSHeaders(cors, req) {
+  const headers = new Headers;
+  if (!cors)
+    return headers;
+  const opts = typeof cors === "object" ? cors : {};
+  const originHeader = req.headers.get("origin") ?? "*";
+  let allowOrigin = "*";
+  if (typeof opts.origin === "function") {
+    const res = opts.origin(originHeader);
+    if (typeof res === "string")
+      allowOrigin = res;
+    else if (res)
+      allowOrigin = originHeader;
+  } else if (typeof opts.origin === "string") {
+    allowOrigin = opts.origin;
+  } else if (Array.isArray(opts.origin)) {
+    if (opts.origin.includes(originHeader))
+      allowOrigin = originHeader;
+  } else {
+    allowOrigin = originHeader || "*";
+  }
+  headers.set("Access-Control-Allow-Origin", allowOrigin);
+  headers.set("Access-Control-Allow-Methods", (opts.methods ?? ["GET", "POST", "OPTIONS", "HEAD"]).join(", "));
+  headers.set("Access-Control-Allow-Headers", (opts.allowedHeaders ?? ["Content-Type", "Authorization", "X-Requested-With"]).join(", "));
+  if (opts.exposedHeaders) {
+    headers.set("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
+  }
+  if (opts.credentials) {
+    headers.set("Access-Control-Allow-Credentials", "true");
+  }
+  if (opts.maxAge !== undefined) {
+    headers.set("Access-Control-Max-Age", opts.maxAge.toString());
+  }
+  return headers;
+}
+function resolveProcedureFromPath(router, path) {
+  const parts = path.split(/[./]/).filter(Boolean);
+  let current = router._def.record;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    if (!current || typeof current !== "object") {
+      throw new RPCError2({
+        code: "NOT_FOUND",
+        message: `Procedure '${path}' not found`
+      });
+    }
+    if (i === parts.length - 1) {
+      if (part in current && "type" in current[part]) {
+        return current[part];
+      }
+      throw new RPCError2({
+        code: "NOT_FOUND",
+        message: `Procedure '${path}' not found`
+      });
+    }
+    if (part in current && "_def" in current[part]) {
+      current = current[part]._def.record;
+    } else if (part in current && typeof current[part] === "object") {
+      current = current[part];
+    } else {
+      throw new RPCError2({
+        code: "NOT_FOUND",
+        message: `Procedure '${path}' not found`
+      });
+    }
+  }
+  throw new RPCError2({
+    code: "NOT_FOUND",
+    message: `Procedure '${path}' not found`
+  });
+}
+function matchesRulePattern(pattern, urlPath, procedurePath) {
+  if (pattern === "*")
+    return true;
+  const cleanUrl = urlPath.replace(/^\/+|\/+$/g, "");
+  const cleanPattern = pattern.replace(/^\/+|\/+$/g, "");
+  const cleanProc = procedurePath.replace(/^\/+|\/+$/g, "");
+  if (cleanUrl === cleanPattern || cleanProc === cleanPattern || cleanProc === cleanPattern.replace(/\//g, ".")) {
+    return true;
+  }
+  if (cleanPattern.endsWith("*")) {
+    const prefix = cleanPattern.slice(0, -1);
+    if (cleanUrl.startsWith(prefix) || cleanProc.startsWith(prefix)) {
+      return true;
+    }
+    const dotPrefix = prefix.replace(/\//g, ".");
+    if (cleanProc.startsWith(dotPrefix)) {
+      return true;
+    }
+  }
+  try {
+    const regexStr = cleanPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(cleanUrl) || regex.test(cleanProc);
+  } catch {
+    return false;
+  }
+}
+function createFetchHandler2(options) {
+  const {
+    router,
+    endpoint = "",
+    createContext,
+    onError,
+    cors = true,
+    securityHeaders = true,
+    rules
+  } = options;
+  return async (request, ...extra) => {
+    const corsHeaders = getCORSHeaders(cors, request);
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: corsHeaders
+      });
+    }
+    const baseHeaders = new Headers(corsHeaders);
+    if (securityHeaders) {
+      if (typeof securityHeaders === "object") {
+        for (const [k, v] of Object.entries(securityHeaders)) {
+          baseHeaders.set(k, v);
+        }
+      } else {
+        baseHeaders.set("X-Content-Type-Options", "nosniff");
+      }
+    }
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (endpoint && pathname.startsWith(endpoint)) {
+      pathname = pathname.slice(endpoint.length);
+    }
+    pathname = pathname.replace(/^\/+|\/+$/g, "");
+    const procedurePath = pathname || url.searchParams.get("procedure") || "";
+    let ctx = {};
+    try {
+      if (createContext) {
+        ctx = await createContext({ req: request, extra });
+      }
+    } catch (err) {
+      const error = err instanceof RPCError2 ? err : new RPCError2({
+        code: "UNAUTHORIZED",
+        message: err.message ?? "Context initialization failed",
+        cause: err
+      });
+      onError?.({ error, req: request });
+      baseHeaders.set("Content-Type", "application/json");
+      return new Response(JSON.stringify({
+        error: {
+          code: error.code,
+          message: error.message,
+          issues: error.issues
+        }
+      }), {
+        status: error.status,
+        headers: baseHeaders
+      });
+    }
+    const rulesList = [];
+    if (rules) {
+      if (Array.isArray(rules)) {
+        rulesList.push(...rules);
+      } else {
+        for (const [match, rule] of Object.entries(rules)) {
+          rulesList.push({ match, ...rule });
+        }
+      }
+    }
+    const matchingRules = rulesList.filter((r) => matchesRulePattern(r.match, url.pathname, procedurePath));
+    for (const rule of matchingRules) {
+      if (rule.requireHeaders) {
+        for (const headerName of rule.requireHeaders) {
+          if (!request.headers.get(headerName)) {
+            const error = new RPCError2({
+              code: "UNAUTHORIZED",
+              message: `Missing required header '${headerName}' for rule '${rule.match}'`
+            });
+            onError?.({ error, path: procedurePath, req: request });
+            baseHeaders.set("Content-Type", "application/json");
+            return new Response(JSON.stringify({
+              error: {
+                code: error.code,
+                message: error.message
+              }
+            }), {
+              status: 401,
+              headers: baseHeaders
+            });
+          }
+        }
+      }
+      if (rule.requireParams) {
+        for (const paramName of rule.requireParams) {
+          if (!url.searchParams.has(paramName)) {
+            const error = new RPCError2({
+              code: "BAD_REQUEST",
+              message: `Missing required query parameter '${paramName}' for rule '${rule.match}'`
+            });
+            onError?.({ error, path: procedurePath, req: request });
+            baseHeaders.set("Content-Type", "application/json");
+            return new Response(JSON.stringify({
+              error: {
+                code: error.code,
+                message: error.message
+              }
+            }), {
+              status: 400,
+              headers: baseHeaders
+            });
+          }
+        }
+      }
+      if (rule.guard) {
+        try {
+          const guardResult = await rule.guard({ req: request, ctx, path: procedurePath });
+          if (guardResult === false) {
+            throw new RPCError2({
+              code: "UNAUTHORIZED",
+              message: `Access denied by route rule guard for '${rule.match}'`
+            });
+          }
+        } catch (err) {
+          const error = err instanceof RPCError2 ? err : new RPCError2({
+            code: "UNAUTHORIZED",
+            message: err.message ?? "Unauthorized",
+            cause: err
+          });
+          onError?.({ error, path: procedurePath, req: request });
+          baseHeaders.set("Content-Type", "application/json");
+          return new Response(JSON.stringify({
+            error: {
+              code: error.code,
+              message: error.message
+            }
+          }), {
+            status: error.status,
+            headers: baseHeaders
+          });
+        }
+      }
+      if (rule.headers) {
+        const resHeaders = typeof rule.headers === "function" ? await rule.headers(request, ctx) : rule.headers;
+        for (const [k, v] of Object.entries(resHeaders)) {
+          baseHeaders.set(k, v);
+        }
+      }
+    }
+    if (request.method === "POST" && (!pathname || pathname === "batch")) {
+      try {
+        const body = await request.json();
+        if (Array.isArray(body)) {
+          const batchResults = await Promise.all(body.map(async (item) => {
+            try {
+              const proc = resolveProcedureFromPath(router, item.path);
+              const data = await executeProcedure2(proc, {
+                rawInput: item.input,
+                ctx,
+                req: request,
+                signal: request.signal
+              });
+              return {
+                id: item.id,
+                result: { data }
+              };
+            } catch (err) {
+              const error = err instanceof RPCError2 ? err : new RPCError2({
+                code: "INTERNAL_SERVER_ERROR",
+                message: err.message ?? "Internal Server Error",
+                cause: err
+              });
+              onError?.({ error, path: item.path, req: request });
+              return {
+                id: item.id,
+                error: {
+                  code: error.code,
+                  message: error.message,
+                  issues: error.issues
+                }
+              };
+            }
+          }));
+          baseHeaders.set("Content-Type", "application/json");
+          return new Response(JSON.stringify(batchResults), {
+            status: 200,
+            headers: baseHeaders
+          });
+        }
+      } catch (err) {
+        const error = new RPCError2({
+          code: "BAD_REQUEST",
+          message: "Malformed batch request body",
+          cause: err
+        });
+        baseHeaders.set("Content-Type", "application/json");
+        return new Response(JSON.stringify({
+          error: {
+            code: error.code,
+            message: error.message
+          }
+        }), {
+          status: 400,
+          headers: baseHeaders
+        });
+      }
+    }
+    try {
+      const procedure = resolveProcedureFromPath(router, procedurePath);
+      if (procedure.type === "mutation" && request.method !== "POST") {
+        throw new RPCError2({
+          code: "METHOD_NOT_ALLOWED",
+          message: "Mutations must use POST method"
+        });
+      }
+      let rawInput;
+      if (request.method === "GET") {
+        const inputParam = url.searchParams.get("input");
+        if (inputParam !== null) {
+          try {
+            rawInput = JSON.parse(inputParam);
+          } catch {
+            rawInput = inputParam;
+          }
+        }
+      } else if (request.method === "POST") {
+        try {
+          const body = await request.json();
+          rawInput = body && typeof body === "object" && "input" in body ? body.input : body;
+        } catch {
+          rawInput = undefined;
+        }
+      }
+      if (procedure.type === "subscription") {
+        const iterable = await executeProcedure2(procedure, {
+          rawInput,
+          ctx,
+          req: request,
+          signal: request.signal
+        });
+        if (!iterable || typeof iterable[Symbol.asyncIterator] !== "function") {
+          throw new RPCError2({
+            code: "INTERNAL_SERVER_ERROR",
+            message: "Subscription procedure must return an AsyncIterable"
+          });
+        }
+        const encoder = new TextEncoder;
+        const stream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const chunk of iterable) {
+                if (request.signal.aborted)
+                  break;
+                const message = `data: ${JSON.stringify(chunk)}
+
+`;
+                controller.enqueue(encoder.encode(message));
+              }
+              controller.close();
+            } catch (err) {
+              const errorMessage = `event: error
+data: ${JSON.stringify({ message: err.message ?? "Stream error" })}
+
+`;
+              controller.enqueue(encoder.encode(errorMessage));
+              controller.close();
+            }
+          },
+          cancel() {
+            if (typeof iterable.return === "function") {
+              iterable.return();
+            }
+          }
+        });
+        baseHeaders.set("Content-Type", "text/event-stream; charset=utf-8");
+        baseHeaders.set("Cache-Control", "no-cache, no-transform");
+        baseHeaders.set("Connection", "keep-alive");
+        return new Response(stream, {
+          status: 200,
+          headers: baseHeaders
+        });
+      }
+      const data = await executeProcedure2(procedure, {
+        rawInput,
+        ctx,
+        req: request,
+        signal: request.signal
+      });
+      const responsePayload = {
+        result: { data }
+      };
+      baseHeaders.set("Content-Type", "application/json");
+      return new Response(JSON.stringify(responsePayload), {
+        status: 200,
+        headers: baseHeaders
+      });
+    } catch (err) {
+      const error = err instanceof RPCError2 ? err : new RPCError2({
+        code: "INTERNAL_SERVER_ERROR",
+        message: err.message ?? "Internal Server Error",
+        cause: err
+      });
+      onError?.({ error, path: procedurePath, req: request });
+      const responsePayload = {
+        error: {
+          code: error.code,
+          message: error.message,
+          issues: error.issues
+        }
+      };
+      baseHeaders.set("Content-Type", "application/json");
+      return new Response(JSON.stringify(responsePayload), {
+        status: ERROR_CODE_TO_STATUS2[error.code] ?? 500,
+        headers: baseHeaders
+      });
+    }
+  };
+}
+
+export { ERROR_CODE_TO_STATUS2, STATUS_TO_ERROR_CODE2, RPCError2, createProcedure2, executeProcedure2, matchesRulePattern, createFetchHandler2 };

package/dist/index-9fvarkrx.js

@@ -0,0 +1,98 @@
+import {
+  formatStyleProp2,
+  resolveValue2,
+  setAttribute2,
+  insertChild2
+} from "./index-6kfe1nr4.js";
+
+// src/jsx-runtime/index.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "g",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "defs",
+  "clipPath",
+  "linearGradient",
+  "radialGradient",
+  "stop"
+]);
+function Fragment2(props) {
+  if (typeof document === "undefined") {
+    return props.children !== undefined ? props.children : [];
+  }
+  const fragment = document.createDocumentFragment();
+  if (props.children !== undefined) {
+    insertChild2(fragment, props.children);
+  }
+  return fragment;
+}
+function jsx2(type, props = {}, key) {
+  if (typeof type === "function") {
+    return type(props, key);
+  }
+  if (typeof type === "string") {
+    const { children, ...restProps } = props;
+    if (typeof document === "undefined") {
+      const attributes = new Map;
+      for (const propName in restProps) {
+        const val = restProps[propName];
+        if (propName === "className" || propName === "class") {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved)
+            attributes.set("class", resolved);
+        } else if (propName === "style") {
+          const val = restProps[propName];
+          const resolved = resolveValue2(val);
+          if (typeof resolved === "string") {
+            attributes.set("style", resolved);
+          } else if (typeof resolved === "object" && resolved !== null) {
+            const styleStr = Object.entries(resolved).map(([k, v]) => {
+              const finalVal = resolveValue2(v);
+              const formatted = formatStyleProp2(k, finalVal);
+              if (!formatted)
+                return "";
+              const kebab = k.startsWith("--") ? k : k.replace(/([A-Z])/g, "-$1").toLowerCase();
+              return `${kebab}: ${formatted}`;
+            }).filter(Boolean).join("; ");
+            if (styleStr)
+              attributes.set("style", styleStr);
+          }
+        } else if (!propName.startsWith("on")) {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved === true) {
+            attributes.set(propName, propName);
+          } else if (resolved !== false && resolved !== null && resolved !== undefined) {
+            attributes.set(propName, resolved);
+          }
+        }
+      }
+      const childNodes = children !== undefined ? Array.isArray(children) ? children : [children] : [];
+      return {
+        tagName: type,
+        attributes,
+        childNodes
+      };
+    }
+    const isSvg = SVG_TAGS.has(type);
+    const element = isSvg ? document.createElementNS(SVG_NS, type) : document.createElement(type);
+    for (const propName in restProps) {
+      setAttribute2(element, propName, restProps[propName]);
+    }
+    if (children !== undefined) {
+      insertChild2(element, children);
+    }
+    return element;
+  }
+  return type;
+}
+var jsxs2 = jsx2;
+var jsxDEV2 = jsx2;
+
+export { Fragment2, jsx2, jsxs2, jsxDEV2 };