@epoch32/visage 1.0.0 → 1.1.1

package/dist/api/client.d.ts

@@ -0,0 +1,5 @@
+import type { ApiClient, ApiClientOptions } from "./types";
+/**
+ * Create a type-safe API client for file-based API routes
+ */
+export declare function createApiClient<TRoutes = any>(options: ApiClientOptions): ApiClient<TRoutes>;

package/dist/api/file-router.d.ts

@@ -0,0 +1,29 @@
+import type { FileRouteModule, RouteMatch } from "./types";
+export interface FileRouteEntry {
+    filePath: string;
+    module: FileRouteModule;
+    sourceCode?: string;
+}
+/**
+ * Compile a route path pattern into a regex and parameter list
+ * e.g. `/admin/users/:id` or `/admin/files/*slug`
+ */
+export declare function compileRoutePattern(path: string): {
+    pattern: RegExp;
+    paramNames: string[];
+};
+/**
+ * Normalize a file path to an API URL route path and directory
+ */
+export declare function normalizeFilePath(rawPath: string): {
+    isMiddleware: boolean;
+    routePath: string;
+    directory: string;
+};
+/**
+ * Build a file-based routing manifest with hierarchical middleware cascades
+ */
+export declare function buildFileRouter(files: Record<string, FileRouteModule | {
+    default?: any;
+    [key: string]: any;
+}>, sourceMap?: Record<string, string>): RouteMatch[];

package/dist/api/handler.d.ts

@@ -0,0 +1,15 @@
+import type { ApiRouterConfig, FileRouteModule, RouteMatch } from "./types";
+/**
+ * Create a standard Web Fetch API handler from compiled route manifests
+ */
+export declare function createApiHandler(routes: RouteMatch[], config?: ApiRouterConfig): (req: Request) => Promise<Response>;
+/**
+ * High-level createApi factory for file-based API routers
+ */
+export declare function createApi(files: Record<string, FileRouteModule | {
+    default?: any;
+    [key: string]: any;
+}>, sourceMapOrConfig?: Record<string, string> | ApiRouterConfig, maybeConfig?: ApiRouterConfig): {
+    routes: RouteMatch[];
+    fetch: (req: Request) => Promise<Response>;
+};

package/dist/api/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Visage File-Based API & Opinionated RPC Framework (visage/api)
+ */
+export { Schema, type SchemaLike, type StandardSchemaV1, type ValidationIssue, type ValidationResult, v, validateWithSchema } from "../form/schema";
+export { ERROR_CODE_TO_STATUS, RPCError, STATUS_TO_ERROR_CODE } from "../rpc/error";
+export { createApiClient } from "./client";
+export { buildFileRouter, compileRoutePattern, type FileRouteEntry, normalizeFilePath } from "./file-router";
+export { createApi, createApiHandler } from "./handler";
+export { executeMiddlewareChain } from "./middleware";
+export { globToRegExp, matchesAnyPattern, parsePragma, shouldApplyMiddleware } from "./pragma";
+export { defineMiddleware, mutation, ProcedureBuilder, procedure, query, subscription } from "./procedure";
+export type { ApiCallOptions, ApiClient, ApiClientHeadersRule, ApiClientOptions, ApiEndpointMethods, ApiMethodCaller, ApiProcedure, ApiRouterConfig, ApiSubscriptionCallbacks, ApiSubscriptionCaller, ApiSubscriptionHandle, FileRouteModule, HttpMethod, InferApiInput, InferApiOutput, MiddlewareContext, MiddlewareDefinition, MiddlewareFn, MiddlewarePragma, NextFn, ProcedureOptions, ProcedureType, RouteMatch, RPCErrorCode } from "./types";

package/dist/{src/api → api}/index.js

@@ -1112,10 +1112,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -1140,6 +1142,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -1165,11 +1170,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/api/middleware.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Visage Middleware Execution Engine & Context Propagation
+ */
+import type { MiddlewareFn } from "./types";
+/**
+ * Execute a chain of middlewares, accumulating context and returning either an early Response or merged Context
+ */
+export declare function executeMiddlewareChain(middlewares: MiddlewareFn[], req: Request, url: URL, params: Record<string, string>, initialCtx?: Record<string, any>): Promise<{
+    response?: Response;
+    ctx: Record<string, any>;
+}>;

package/dist/api/pragma.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Visage API Pragma Parser & Path Pattern Matcher
+ * Parses `// @visage-middleware` pragmas at the top of middleware files.
+ */
+import type { MiddlewarePragma } from "./types";
+/**
+ * Parse top-level `// @visage-middleware` pragma from file source code
+ */
+export declare function parsePragma(sourceCode: string): MiddlewarePragma;
+/**
+ * Convert a glob-like pattern (e.g. `admin/*`, `users/**`, `stats`) into a RegExp
+ */
+export declare function globToRegExp(pattern: string): RegExp;
+/**
+ * Test whether a normalized route path matches any glob pattern in a list
+ */
+export declare function matchesAnyPattern(routePath: string, patterns: string[]): boolean;
+/**
+ * Evaluate if a middleware definition should apply to a specific route
+ */
+export declare function shouldApplyMiddleware(pragma: MiddlewarePragma, routePath: string, routeDir: string, middlewareDir: string): boolean;

package/dist/api/procedure.d.ts

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

package/dist/api/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * 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/dist/charts/Area.d.ts

@@ -0,0 +1,18 @@
+import type { Child } from "../dom";
+import type { CurveType } 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 declare function Area(props: AreaProps): Child;

package/dist/charts/Axis.d.ts

@@ -0,0 +1,21 @@
+import type { Child } from "../dom";
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormat?: (val: any, index: number) => string;
+    tickCount?: number;
+    stroke?: string;
+    fontSize?: number | string;
+    fontFamily?: string;
+    hideLine?: boolean;
+}
+export declare function XAxis(props: XAxisProps): Child;
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormat?: (val: any, index: number) => string;
+    unit?: string;
+    tickCount?: number;
+    stroke?: string;
+    fontSize?: number | string;
+    hideLine?: boolean;
+}
+export declare function YAxis(props: YAxisProps): Child;

package/dist/charts/Bar.d.ts

@@ -0,0 +1,10 @@
+import type { Child } from "../dom";
+export interface BarProps {
+    dataKey: string;
+    fill?: string;
+    radius?: number;
+    maxWidth?: number;
+    name?: string;
+    opacity?: number | string;
+}
+export declare function Bar(props: BarProps): Child;

package/dist/charts/CartesianGrid.d.ts

@@ -0,0 +1,10 @@
+import type { Child } from "../dom";
+export interface CartesianGridProps {
+    horizontal?: boolean;
+    vertical?: boolean;
+    stroke?: string;
+    strokeWidth?: number | string;
+    strokeDasharray?: string;
+    opacity?: number | string;
+}
+export declare function CartesianGrid(props: CartesianGridProps): Child;

package/dist/charts/Chart.d.ts

@@ -0,0 +1,16 @@
+import { type Child } from "../dom";
+import type { ClassProp, ReactiveProp } from "../jsx-runtime/jsx";
+import type { Margin } from "./types";
+export interface ChartProps {
+    data: ReactiveProp<any[]>;
+    width?: number | string;
+    height?: number | string;
+    margin?: Partial<Margin>;
+    yDomain?: [number, number];
+    class?: ClassProp;
+    className?: ClassProp;
+    style?: any;
+    children?: Child;
+    [key: string]: any;
+}
+export declare function Chart(props: ChartProps): Child;

package/dist/charts/Cursor.d.ts

@@ -0,0 +1,8 @@
+import type { Child } from "../dom";
+export interface ChartCursorProps {
+    stroke?: string;
+    strokeWidth?: number | string;
+    strokeDasharray?: string;
+    opacity?: number | string;
+}
+export declare function ChartCursor(props: ChartCursorProps): Child;

package/dist/charts/Legend.d.ts

@@ -0,0 +1,9 @@
+import type { Child } from "../dom";
+import type { ClassProp } from "../jsx-runtime/jsx";
+export interface LegendProps {
+    align?: "left" | "center" | "right";
+    class?: ClassProp;
+    className?: ClassProp;
+}
+export declare function ChartLegend(props: LegendProps): Child;
+export declare const Legend: typeof ChartLegend;

package/dist/charts/Line.d.ts

@@ -0,0 +1,18 @@
+import type { Child } from "../dom";
+import type { CurveType } from "./types";
+export interface LineProps {
+    dataKey: string;
+    stroke?: string;
+    strokeWidth?: number | string;
+    strokeDasharray?: string;
+    curve?: CurveType;
+    dot?: boolean | {
+        r?: number;
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    name?: string;
+    opacity?: number | string;
+}
+export declare function Line(props: LineProps): Child;

package/dist/charts/Pie.d.ts

@@ -0,0 +1,12 @@
+import type { Child } from "../dom";
+export interface PieProps {
+    dataKey: string;
+    nameKey?: string;
+    innerRadius?: number;
+    outerRadius?: number;
+    colors?: string[];
+    cx?: number;
+    cy?: number;
+    padAngle?: number;
+}
+export declare function Pie(props: PieProps): Child;

package/dist/charts/Tooltip.d.ts

@@ -0,0 +1,12 @@
+import type { Child } from "../dom";
+import type { ClassProp } from "../jsx-runtime/jsx";
+import type { SeriesMeta } from "./types";
+export interface TooltipProps {
+    format?: (val: any, name: string) => string;
+    labelFormat?: (label: any) => string;
+    content?: (datum: any, series: SeriesMeta[]) => Child;
+    class?: ClassProp;
+    className?: ClassProp;
+}
+export declare function ChartTooltip(props: TooltipProps): Child;
+export declare const Tooltip: typeof ChartTooltip;

package/dist/charts/context.d.ts

@@ -0,0 +1,20 @@
+import type { AnyScale, HoverState, LinearScale, Margin, SeriesMeta } from "./types";
+export interface ChartContextValue {
+    data: () => any[];
+    width: () => number;
+    height: () => number;
+    margin: Margin;
+    innerWidth: () => number;
+    innerHeight: () => number;
+    xScale: () => AnyScale;
+    yScale: () => LinearScale;
+    hoverState: () => HoverState;
+    setHoverState: (state: HoverState) => void;
+    xDataKey: () => string | undefined;
+    setXDataKey: (key: string) => void;
+    series: () => SeriesMeta[];
+    registerSeries: (meta: SeriesMeta) => void;
+    unregisterSeries: (id: string) => void;
+}
+export declare const ChartContext: import("..").Context<ChartContextValue | undefined>;
+export declare function useChartContext(): ChartContextValue;

package/dist/charts/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./Area";
+export * from "./Axis";
+export * from "./Bar";
+export * from "./CartesianGrid";
+export * from "./Chart";
+export * from "./Cursor";
+export * from "./context";
+export * from "./Legend";
+export * from "./Line";
+export * from "./Pie";
+export * from "./path";
+export * from "./scale";
+export * from "./Tooltip";
+export * from "./types";