@epoch32/visage 0.0.0-stage → 1.0.0

package/src/api/procedure.ts

@@ -0,0 +1,172 @@
+import type { InferSchemaType, SchemaLike, StandardSchemaV1 } from "../form/schema";
+import type {
+  ApiProcedure,
+  MiddlewareDefinition,
+  MiddlewareFn,
+  MiddlewarePragma,
+  ProcedureOptions
+} from "./types";
+
+/**
+ * Define a type-safe Query procedure
+ */
+export function query<
+  TSchema extends SchemaLike<any> | StandardSchemaV1<any>,
+  TOutput = any,
+  TCtx = any
+>(options: {
+  input: TSchema;
+  output?: SchemaLike<TOutput> | StandardSchemaV1<TOutput>;
+  resolve: (args: {
+    input: InferSchemaType<TSchema>;
+    ctx: TCtx;
+    req: Request;
+    params: Record<string, string>;
+  }) => Promise<TOutput> | TOutput | AsyncGenerator<any, void, unknown>;
+}): ApiProcedure<InferSchemaType<TSchema>, TOutput, TCtx>;
+export function query<TInput = void, TOutput = any, TCtx = any>(
+  options: ProcedureOptions<TInput, TOutput, TCtx>
+): ApiProcedure<TInput, TOutput, TCtx>;
+export function query(options: any): ApiProcedure<any, any, any> {
+  return {
+    type: "query",
+    options
+  };
+}
+
+/**
+ * Define a type-safe Mutation procedure
+ */
+export function mutation<
+  TSchema extends SchemaLike<any> | StandardSchemaV1<any>,
+  TOutput = any,
+  TCtx = any
+>(options: {
+  input: TSchema;
+  output?: SchemaLike<TOutput> | StandardSchemaV1<TOutput>;
+  resolve: (args: {
+    input: InferSchemaType<TSchema>;
+    ctx: TCtx;
+    req: Request;
+    params: Record<string, string>;
+  }) => Promise<TOutput> | TOutput | AsyncGenerator<any, void, unknown>;
+}): ApiProcedure<InferSchemaType<TSchema>, TOutput, TCtx>;
+export function mutation<TInput = void, TOutput = any, TCtx = any>(
+  options: ProcedureOptions<TInput, TOutput, TCtx>
+): ApiProcedure<TInput, TOutput, TCtx>;
+export function mutation(options: any): ApiProcedure<any, any, any> {
+  return {
+    type: "mutation",
+    options
+  };
+}
+
+/**
+ * Define a real-time SSE / Stream Subscription procedure
+ */
+export function subscription<TOutput = any, TCtx = any>(
+  options: Omit<ProcedureOptions<void, TOutput, TCtx>, "input">
+): ApiProcedure<void, TOutput, TCtx> {
+  return {
+    type: "subscription",
+    options: {
+      ...options,
+      resolve: options.resolve as any
+    }
+  };
+}
+
+/**
+ * Helper to define a middleware function with optional pragma metadata
+ */
+export function defineMiddleware<TCtxIn = any, TCtxOut = any>(
+  fn: MiddlewareFn<TCtxIn, TCtxOut>,
+  pragma: MiddlewarePragma = { cascade: true, match: ["*"] }
+): MiddlewareDefinition {
+  return {
+    fn,
+    pragma
+  };
+}
+
+/**
+ * Composable Procedure Builder (Fluent Style)
+ */
+export class ProcedureBuilder<TCtx = any, TInput = any> {
+  private _middlewares: MiddlewareFn[] = [];
+  private _inputSchema?: SchemaLike<TInput> | StandardSchemaV1<TInput>;
+
+  constructor(middlewares: MiddlewareFn[] = [], inputSchema?: SchemaLike<TInput>) {
+    this._middlewares = middlewares;
+    this._inputSchema = inputSchema;
+  }
+
+  use<TNextCtx = Record<string, unknown>>(
+    middleware: MiddlewareFn<TCtx, TNextCtx>
+  ): ProcedureBuilder<TCtx & TNextCtx, TInput> {
+    return new ProcedureBuilder<TCtx & TNextCtx, TInput>(
+      [...this._middlewares, middleware],
+      this._inputSchema as any
+    );
+  }
+
+  input<TNewInput>(
+    schema: SchemaLike<TNewInput> | StandardSchemaV1<TNewInput>
+  ): ProcedureBuilder<TCtx, TNewInput> {
+    return new ProcedureBuilder<TCtx, TNewInput>(this._middlewares, schema as any);
+  }
+
+  query<TOutput>(
+    resolve: (args: {
+      input: TInput;
+      ctx: TCtx;
+      req: Request;
+      params: Record<string, string>;
+    }) => Promise<TOutput> | TOutput
+  ): ApiProcedure<TInput, TOutput, TCtx> {
+    return {
+      type: "query",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+
+  mutation<TOutput>(
+    resolve: (args: {
+      input: TInput;
+      ctx: TCtx;
+      req: Request;
+      params: Record<string, string>;
+    }) => Promise<TOutput> | TOutput
+  ): ApiProcedure<TInput, TOutput, TCtx> {
+    return {
+      type: "mutation",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+
+  subscription<TOutput>(
+    resolve: (args: {
+      ctx: TCtx;
+      req: Request;
+      params: Record<string, string>;
+    }) => AsyncGenerator<TOutput, void, unknown>
+  ): ApiProcedure<void, TOutput, TCtx> {
+    return {
+      type: "subscription",
+      options: {
+        resolve: resolve as any
+      },
+      middlewares: this._middlewares
+    };
+  }
+}
+
+export const procedure = new ProcedureBuilder<Record<string, unknown>>();

package/src/api/types.ts

@@ -0,0 +1,249 @@
+/**
+ * Visage API & File-Based RPC Routing System Types
+ */
+import type { SchemaLike, StandardSchemaV1 } from "../form/schema";
+import type { RPCErrorCode } from "../rpc/types";
+
+export type { RPCErrorCode };
+
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+
+export interface MiddlewarePragma {
+  /**
+   * Whether this middleware cascades to child subdirectories.
+   * Default: true
+   */
+  cascade?: boolean;
+
+  /**
+   * Route name / path globs to include.
+   * Default: ["*"]
+   */
+  match?: string[];
+
+  /**
+   * Route name / path globs to exclude.
+   * Default: []
+   */
+  exclude?: string[];
+
+  /**
+   * Execution priority within the same directory (higher runs earlier).
+   * Default: 0
+   */
+  priority?: number;
+}
+
+export type NextFn<TCtxIn = any, TCtxOut = any> = (
+  enriched?: Partial<TCtxOut>
+) => Promise<Response | (TCtxIn & TCtxOut)>;
+
+export interface MiddlewareContext<TCtx = any> {
+  req: Request;
+  ctx: TCtx;
+  url: URL;
+  params: Record<string, string>;
+  next: NextFn<TCtx, any>;
+}
+
+export type MiddlewareFn<TCtxIn = any, _TCtxOut = any> = (
+  args: MiddlewareContext<TCtxIn>
+) => Promise<Response | void | any>;
+
+export interface MiddlewareDefinition {
+  fn: MiddlewareFn;
+  pragma: MiddlewarePragma;
+  filePath?: string;
+  directory?: string;
+}
+
+export type ProcedureType = "query" | "mutation" | "subscription";
+
+export interface ProcedureOptions<TInput = any, TOutput = any, TCtx = any> {
+  input?: SchemaLike<TInput> | StandardSchemaV1<TInput>;
+  output?: SchemaLike<TOutput> | StandardSchemaV1<TOutput>;
+  resolve: (args: {
+    input: TInput;
+    ctx: TCtx;
+    req: Request;
+    params: Record<string, string>;
+  }) => Promise<TOutput> | TOutput | AsyncGenerator<any, void, unknown>;
+}
+
+export interface ApiProcedure<TInput = any, TOutput = any, TCtx = any> {
+  type: ProcedureType;
+  options: ProcedureOptions<TInput, TOutput, TCtx>;
+  middlewares?: MiddlewareFn[];
+}
+
+export interface RouteMatch {
+  pattern: RegExp;
+  paramNames: string[];
+  routePath: string;
+  filePath: string;
+  directory: string;
+  procedures: Record<string, ApiProcedure>;
+  middlewares: MiddlewareDefinition[];
+  handler?: (req: Request, ctx: any) => Promise<Response> | Response;
+}
+
+export interface FileRouteModule {
+  default?: ApiProcedure | ((req: Request, ctx?: any) => Promise<Response> | Response);
+  middleware?: MiddlewareFn;
+  get?: ApiProcedure;
+  post?: ApiProcedure;
+  put?: ApiProcedure;
+  del?: ApiProcedure;
+  patch?: ApiProcedure;
+  [key: string]: any;
+}
+
+export interface ApiRouterConfig {
+  prefix?: string;
+  cors?: {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    allowedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+  };
+  onError?: (err: Error, req: Request) => Response | Promise<Response>;
+}
+
+export type ApiClientHeadersRule =
+  | Record<string, string>
+  | (() => Promise<Record<string, string>> | Record<string, string>);
+
+export interface ApiClientOptions {
+  baseUrl: string;
+  fetch?: typeof fetch;
+  headers?:
+    | Record<string, string>
+    | Record<string, ApiClientHeadersRule>
+    | (() => Promise<Record<string, string>> | Record<string, string>);
+}
+
+export interface ApiCallOptions {
+  signal?: AbortSignal;
+  headers?: Record<string, string>;
+}
+
+export interface ApiSubscriptionCallbacks<TData = any> {
+  onData: (data: TData) => void;
+  onError?: (error: any) => void;
+  onComplete?: () => void;
+}
+
+export interface ApiSubscriptionHandle {
+  unsubscribe: () => void;
+}
+
+export type InferApiInput<P> =
+  P extends ApiProcedure<infer TInput, any, any>
+    ? TInput
+    : P extends (...args: any[]) => any
+      ? any
+      : void;
+
+export type InferApiOutput<P> =
+  P extends ApiProcedure<any, infer TOutput, any>
+    ? TOutput
+    : P extends (...args: any[]) => Promise<infer TOutput>
+      ? TOutput
+      : unknown;
+
+export type ApiMethodCaller<P> =
+  InferApiInput<P> extends void | undefined
+    ? (input?: void, options?: ApiCallOptions) => Promise<InferApiOutput<P>>
+    : (input: InferApiInput<P>, options?: ApiCallOptions) => Promise<InferApiOutput<P>>;
+
+export type ApiSubscriptionCaller<P> =
+  InferApiInput<P> extends void | undefined
+    ? (
+        input: void | undefined,
+        callbacks: ApiSubscriptionCallbacks<InferApiOutput<P>>
+      ) => ApiSubscriptionHandle
+    : (
+        input: InferApiInput<P>,
+        callbacks: ApiSubscriptionCallbacks<InferApiOutput<P>>
+      ) => ApiSubscriptionHandle;
+
+export type ApiEndpointMethods<T> = {
+  get: T extends { GET: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { get: infer P }
+      ? ApiMethodCaller<P>
+      : T extends { default: infer P }
+        ? ApiMethodCaller<P>
+        : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  post: T extends { POST: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { post: infer P }
+      ? ApiMethodCaller<P>
+      : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  put: T extends { PUT: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { put: infer P }
+      ? ApiMethodCaller<P>
+      : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  patch: T extends { PATCH: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { patch: infer P }
+      ? ApiMethodCaller<P>
+      : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  del: T extends { DELETE: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { del: infer P }
+      ? ApiMethodCaller<P>
+      : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  delete: T extends { DELETE: infer P }
+    ? ApiMethodCaller<P>
+    : T extends { del: infer P }
+      ? ApiMethodCaller<P>
+      : (input?: any, options?: ApiCallOptions) => Promise<any>;
+  subscribe: T extends { GET: infer P }
+    ? ApiSubscriptionCaller<P>
+    : T extends { subscription: infer P }
+      ? ApiSubscriptionCaller<P>
+      : (input: any, callbacks: ApiSubscriptionCallbacks) => ApiSubscriptionHandle;
+
+  queryKey: (input?: any) => unknown[];
+  queryOptions: (input?: any, extra?: any) => any;
+  createQuery: (input?: any, extra?: any) => any;
+  useQuery: (input?: any, extra?: any) => any;
+
+  mutationKey: () => unknown[];
+  mutationOptions: (extra?: any) => any;
+  createMutation: (extra?: any) => any;
+  useMutation: (extra?: any) => any;
+};
+
+export type DynamicApiClient = {
+  get: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  post: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  put: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  patch: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  del: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  delete: (input?: any, options?: ApiCallOptions) => Promise<any>;
+  subscribe: (input: any, callbacks: ApiSubscriptionCallbacks) => ApiSubscriptionHandle;
+  queryKey: (input?: any) => unknown[];
+  queryOptions: (input?: any, extra?: any) => any;
+  createQuery: (input?: any, extra?: any) => any;
+  useQuery: (input?: any, extra?: any) => any;
+  mutationKey: () => unknown[];
+  mutationOptions: (extra?: any) => any;
+  createMutation: (extra?: any) => any;
+  useMutation: (extra?: any) => any;
+  (param: string | number): DynamicApiClient;
+} & Record<string, any>;
+
+export type ApiClient<TRoutes = any> = 0 extends 1 & TRoutes
+  ? DynamicApiClient
+  : [TRoutes] extends [Record<string, any>]
+    ? {
+        [K in keyof TRoutes]-?: ((param: string | number) => ApiClient<TRoutes[K]>) &
+          ApiEndpointMethods<TRoutes[K]> &
+          ApiClient<TRoutes[K]>;
+      } & ((param: string | number) => any) &
+        ApiEndpointMethods<any>
+    : DynamicApiClient;

package/src/charts/Area.tsx

@@ -0,0 +1,111 @@
+import type { Child } from "../dom";
+import { onCleanup } from "../signals";
+import { useChartContext } from "./context";
+import { pathArea, pathLine } from "./path";
+import type { CurveType, Point } from "./types";
+
+export interface AreaProps {
+  dataKey: string;
+  stroke?: string;
+  strokeWidth?: number | string;
+  fill?: string;
+  fillOpacity?: number | string;
+  curve?: CurveType;
+  dot?: boolean | { r?: number; fill?: string; stroke?: string };
+  name?: string;
+  opacity?: number | string;
+}
+
+export function Area(props: AreaProps): Child {
+  return () => {
+    const ctx = useChartContext();
+
+    const stroke = props.stroke ?? "#a855f7";
+    const strokeWidth = props.strokeWidth ?? 2;
+    const fill = props.fill ?? "rgba(168, 85, 247, 0.15)";
+    const fillOpacity = props.fillOpacity ?? 1;
+    const curve = props.curve ?? "smooth";
+
+    const id = `area-${props.dataKey}-${Math.random().toString(36).slice(2, 7)}`;
+
+    ctx.registerSeries({
+      id,
+      dataKey: props.dataKey,
+      type: "area",
+      color: stroke,
+      name: props.name ?? props.dataKey
+    });
+
+    onCleanup(() => {
+      ctx.unregisterSeries(id);
+    });
+
+    return (
+      <g class={`visage-area-${props.dataKey}`} opacity={props.opacity ?? 1}>
+        {() => {
+          const dataArr = ctx.data();
+          if (dataArr.length === 0) return null;
+
+          const xScale = ctx.xScale();
+          const yScale = ctx.yScale();
+          const baselineY = ctx.innerHeight();
+
+          const points: Point[] = [];
+          for (let i = 0; i < dataArr.length; i++) {
+            const item = dataArr[i];
+            const val = item[props.dataKey];
+            if (typeof val !== "number" || Number.isNaN(val)) continue;
+
+            let x = 0;
+            if (xScale.type === "band") {
+              x = xScale(i) + xScale.bandwidth() / 2;
+            } else {
+              x = xScale(i);
+            }
+
+            const y = yScale(val);
+            points.push({ x, y });
+          }
+
+          const areaD = pathArea(points, baselineY, { curve });
+          const lineD = pathLine(points, { curve });
+
+          const dots: Child[] = [];
+          if (props.dot && points.length > 0) {
+            const dotCfg = typeof props.dot === "object" ? props.dot : {};
+            const r = dotCfg.r ?? 3.5;
+            const dotFill = dotCfg.fill ?? "#ffffff";
+            const dotStroke = dotCfg.stroke ?? stroke;
+
+            for (let i = 0; i < points.length; i++) {
+              const p = points[i]!;
+              dots.push(
+                <circle
+                  cx={p.x}
+                  cy={p.y}
+                  r={r}
+                  fill={dotFill}
+                  stroke={dotStroke}
+                  stroke-width={2}
+                />
+              );
+            }
+          }
+
+          return [
+            <path d={areaD} fill={fill} fill-opacity={fillOpacity} />,
+            <path
+              d={lineD}
+              fill="none"
+              stroke={stroke}
+              stroke-width={strokeWidth}
+              stroke-linejoin="round"
+              stroke-linecap="round"
+            />,
+            ...dots
+          ];
+        }}
+      </g>
+    );
+  };
+}

package/src/charts/Axis.tsx

@@ -0,0 +1,126 @@
+import type { Child } from "../dom";
+import { onCleanup } from "../signals";
+import { useChartContext } from "./context";
+
+export interface XAxisProps {
+  dataKey?: string;
+  tickFormat?: (val: any, index: number) => string;
+  tickCount?: number;
+  stroke?: string;
+  fontSize?: number | string;
+  fontFamily?: string;
+  hideLine?: boolean;
+}
+
+export function XAxis(props: XAxisProps): Child {
+  return () => {
+    const ctx = useChartContext();
+
+    if (props.dataKey) {
+      ctx.setXDataKey(props.dataKey);
+      onCleanup(() => {
+        if (ctx.xDataKey() === props.dataKey) {
+          ctx.setXDataKey("");
+        }
+      });
+    }
+
+    const stroke = props.stroke ?? "#94a3b8";
+    const fontSize = props.fontSize ?? 11;
+    const hideLine = props.hideLine ?? false;
+
+    const w = ctx.innerWidth();
+    const h = ctx.innerHeight();
+    const xScale = ctx.xScale();
+    const dataArr = ctx.data();
+
+    const elements: Child[] = [];
+
+    if (!hideLine) {
+      elements.push(<line x1={0} y1={h} x2={w} y2={h} stroke={stroke} stroke-width={1} />);
+    }
+
+    if (xScale.type === "band") {
+      const ticks = xScale.ticks();
+      const bw = xScale.bandwidth();
+      for (let i = 0; i < ticks.length; i++) {
+        const val = ticks[i];
+        const x = xScale(i) + bw / 2;
+        const text = props.tickFormat ? props.tickFormat(val, i) : String(val);
+        elements.push(
+          <text x={x} y={h + 16} text-anchor="middle" font-size={fontSize} fill={stroke}>
+            {text}
+          </text>
+        );
+      }
+    } else {
+      const count = props.tickCount ?? 5;
+      const ticks = xScale.ticks(count);
+      for (let i = 0; i < ticks.length; i++) {
+        const tickIdx = ticks[i]!;
+        const x = xScale(tickIdx);
+        const idx = Math.max(0, Math.min(dataArr.length - 1, Math.round(tickIdx)));
+        const rawItem = dataArr[idx];
+        const rawVal = props.dataKey && rawItem ? rawItem[props.dataKey] : idx;
+        const text = props.tickFormat ? props.tickFormat(rawVal, i) : String(rawVal ?? idx);
+
+        elements.push(
+          <text x={x} y={h + 16} text-anchor="middle" font-size={fontSize} fill={stroke}>
+            {text}
+          </text>
+        );
+      }
+    }
+
+    return <g class="visage-x-axis">{elements}</g>;
+  };
+}
+
+export interface YAxisProps {
+  dataKey?: string;
+  tickFormat?: (val: any, index: number) => string;
+  unit?: string;
+  tickCount?: number;
+  stroke?: string;
+  fontSize?: number | string;
+  hideLine?: boolean;
+}
+
+export function YAxis(props: YAxisProps): Child {
+  return () => {
+    const ctx = useChartContext();
+
+    const stroke = props.stroke ?? "#94a3b8";
+    const fontSize = props.fontSize ?? 11;
+    const hideLine = props.hideLine ?? true;
+    const unit = props.unit ?? "";
+
+    const h = ctx.innerHeight();
+    const yScale = ctx.yScale();
+    const ticks = yScale.ticks(props.tickCount ?? 5);
+
+    const elements: Child[] = [];
+
+    if (!hideLine) {
+      elements.push(<line x1={0} y1={0} x2={0} y2={h} stroke={stroke} stroke-width={1} />);
+    }
+
+    for (let i = 0; i < ticks.length; i++) {
+      const val = ticks[i]!;
+      const y = yScale(val);
+      const formatted = props.tickFormat
+        ? props.tickFormat(val, i)
+        : unit
+          ? `${val}${unit}`
+          : String(val);
+
+      elements.push(
+        <text x={-8} y={y + 4} text-anchor="end" font-size={fontSize} fill={stroke}>
+          {formatted}
+        </text>
+      );
+    }
+
+    return <g class="visage-y-axis">{elements}</g>;
+  };
+}