@epoch32/visage 1.1.3 → 1.1.4

package/dist/vite/index.js

@@ -1,3 +1,7 @@
+import {
+  createFetchHandler2
+} from "../index-965ryh36.js";
+
 // src/vite/lucide.ts
 function parseNamedImports(importClause) {
   return importClause.split(",").map((s) => s.trim()).filter(Boolean).map((item) => {
@@ -97,753 +101,10 @@ if (import.meta.hot) {
   };
 }
 
-// src/rpc/error.ts
-var ERROR_CODE_TO_STATUS = {
-  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_CODE = {
-  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 RPCError extends Error {
-  code;
-  status;
-  issues;
-  constructor(codeOrStatusOrOptions, message) {
-    if (typeof codeOrStatusOrOptions === "number") {
-      const code = STATUS_TO_ERROR_CODE[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_STATUS[codeOrStatusOrOptions] || 500;
-    } else {
-      super(codeOrStatusOrOptions.message ?? codeOrStatusOrOptions.code, {
-        cause: codeOrStatusOrOptions.cause
-      });
-      this.name = "RPCError";
-      this.code = codeOrStatusOrOptions.code;
-      this.status = ERROR_CODE_TO_STATUS[codeOrStatusOrOptions.code] ?? 500;
-      this.issues = codeOrStatusOrOptions.issues;
-    }
-  }
-  get statusCode() {
-    return this.status;
-  }
-}
-
-// src/form/schema.ts
-class Schema {
-  "~standard" = {
-    version: 1,
-    vendor: "visage",
-    validate: (val) => {
-      const res = this.validate(val);
-      if (res.success) {
-        return { value: res.data };
-      }
-      return {
-        issues: (res.issues || []).map((i) => ({
-          path: [i.path],
-          message: i.message
-        }))
-      };
-    }
-  };
-}
-
-class StringSchema extends Schema {
-  _min;
-  _max;
-  _emailMsg;
-  _regex;
-  _isOptional = false;
-  min(length, message) {
-    this._min = { val: length, msg: message };
-    return this;
-  }
-  max(length, message) {
-    this._max = { val: length, msg: message };
-    return this;
-  }
-  email(message) {
-    this._emailMsg = message ?? "Invalid email address";
-    return this;
-  }
-  regex(pattern, message) {
-    this._regex = { pattern, msg: message };
-    return this;
-  }
-  optional() {
-    this._isOptional = true;
-    return this;
-  }
-  validate(value, path = "") {
-    if (value === undefined || value === null || value === "") {
-      if (this._isOptional)
-        return { success: true, data: undefined };
-      return { success: false, issues: [{ path, message: "This field is required" }] };
-    }
-    if (typeof value !== "string") {
-      return { success: false, issues: [{ path, message: "Must be a string" }] };
-    }
-    if (this._min && value.length < this._min.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val} characters` }]
-      };
-    }
-    if (this._max && value.length > this._max.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val} characters` }]
-      };
-    }
-    if (this._emailMsg) {
-      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      if (!emailRegex.test(value)) {
-        return { success: false, issues: [{ path, message: this._emailMsg }] };
-      }
-    }
-    if (this._regex && !this._regex.pattern.test(value)) {
-      return {
-        success: false,
-        issues: [{ path, message: this._regex.msg ?? "Invalid format" }]
-      };
-    }
-    return { success: true, data: value };
-  }
-}
-
-class NumberSchema extends Schema {
-  _min;
-  _max;
-  _integer;
-  _isOptional = false;
-  min(value, message) {
-    this._min = { val: value, msg: message };
-    return this;
-  }
-  max(value, message) {
-    this._max = { val: value, msg: message };
-    return this;
-  }
-  integer(message) {
-    this._integer = { msg: message };
-    return this;
-  }
-  optional() {
-    this._isOptional = true;
-    return this;
-  }
-  validate(value, path = "") {
-    if (value === undefined || value === null || value === "") {
-      if (this._isOptional)
-        return { success: true, data: undefined };
-      return { success: false, issues: [{ path, message: "This field is required" }] };
-    }
-    const num = Number(value);
-    if (Number.isNaN(num) || typeof value === "boolean") {
-      return { success: false, issues: [{ path, message: "Must be a valid number" }] };
-    }
-    if (this._integer && !Number.isInteger(num)) {
-      return {
-        success: false,
-        issues: [{ path, message: this._integer.msg ?? "Must be an integer" }]
-      };
-    }
-    if (this._min && num < this._min.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val}` }]
-      };
-    }
-    if (this._max && num > this._max.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val}` }]
-      };
-    }
-    return { success: true, data: num };
-  }
-}
-
-class BooleanSchema extends Schema {
-  validate(value, _path = "") {
-    return { success: true, data: Boolean(value) };
-  }
-}
-
-class ObjectSchema extends Schema {
-  shape;
-  constructor(shape) {
-    super();
-    this.shape = shape;
-  }
-  validate(value, basePath = "") {
-    if (typeof value !== "object" || value === null) {
-      return { success: false, issues: [{ path: basePath, message: "Must be an object" }] };
-    }
-    const issues = [];
-    const data = {};
-    for (const key in this.shape) {
-      const fieldSchema = this.shape[key];
-      const fieldVal = value[key];
-      const fieldPath = basePath ? `${basePath}.${key}` : key;
-      const res = validateWithSchema(fieldSchema, fieldVal, fieldPath);
-      if (res.success) {
-        data[key] = res.data;
-      } else if (res.issues) {
-        issues.push(...res.issues);
-      }
-    }
-    if (issues.length > 0) {
-      return { success: false, issues };
-    }
-    return { success: true, data };
-  }
-}
-function validateWithSchema(schema, value, path = "") {
-  if (!schema)
-    return { success: true, data: value };
-  if (schema instanceof Schema) {
-    return schema.validate(value, path);
-  }
-  if (typeof schema === "object" && "~standard" in schema) {
-    const res = schema["~standard"].validate(value);
-    if ("value" in res) {
-      return { success: true, data: res.value };
-    }
-    return {
-      success: false,
-      issues: res.issues.map((i) => ({
-        path: i.path ? i.path.join(".") : path,
-        message: i.message
-      }))
-    };
-  }
-  if (typeof schema === "function") {
-    const res = schema(value);
-    if (res === true || res === null || res === undefined) {
-      return { success: true, data: value };
-    }
-    if (typeof res === "string") {
-      return { success: false, issues: [{ path, message: res }] };
-    }
-    if (typeof res === "object") {
-      return res;
-    }
-  }
-  return { success: true, data: value };
-}
-var v = {
-  string: () => new StringSchema,
-  number: () => new NumberSchema,
-  boolean: () => new BooleanSchema,
-  object: (shape) => new ObjectSchema(shape)
-};
-
-// src/rpc/procedure.ts
-function createProcedure(type, options, middlewares = []) {
-  return {
-    type,
-    inputSchema: options.input,
-    outputSchema: options.output,
-    middlewares: [...middlewares],
-    resolve: options.resolve
-  };
-}
-async function executeProcedure(procedure, opts) {
-  let input = opts.rawInput;
-  if (procedure.inputSchema) {
-    const res = validateWithSchema(procedure.inputSchema, opts.rawInput);
-    if (!res.success) {
-      throw new RPCError({
-        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 = validateWithSchema(procedure.outputSchema, output);
-    if (!res.success) {
-      throw new RPCError({
-        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 RPCError({
-        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 RPCError({
-        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 RPCError({
-        code: "NOT_FOUND",
-        message: `Procedure '${path}' not found`
-      });
-    }
-  }
-  throw new RPCError({
-    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 createFetchHandler(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 RPCError ? err : new RPCError({
-        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 RPCError({
-              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 RPCError({
-              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 RPCError({
-              code: "UNAUTHORIZED",
-              message: `Access denied by route rule guard for '${rule.match}'`
-            });
-          }
-        } catch (err) {
-          const error = err instanceof RPCError ? err : new RPCError({
-            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 executeProcedure(proc, {
-                rawInput: item.input,
-                ctx,
-                req: request,
-                signal: request.signal
-              });
-              return {
-                id: item.id,
-                result: { data }
-              };
-            } catch (err) {
-              const error = err instanceof RPCError ? err : new RPCError({
-                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 RPCError({
-          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 RPCError({
-          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 executeProcedure(procedure, {
-          rawInput,
-          ctx,
-          req: request,
-          signal: request.signal
-        });
-        if (!iterable || typeof iterable[Symbol.asyncIterator] !== "function") {
-          throw new RPCError({
-            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 executeProcedure(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 RPCError ? err : new RPCError({
-        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_STATUS[error.code] ?? 500,
-        headers: baseHeaders
-      });
-    }
-  };
-}
-
 // src/vite/rpc-middleware.ts
 function createViteRpcMiddleware(options) {
   const endpoint = options.endpoint ?? "/api/rpc";
-  const handler = createFetchHandler({
+  const handler = createFetchHandler2({
     router: options.router,
     endpoint,
     cors: true