@epoch32/visage 0.0.0-stage → 0.0.0

package/src/form/schema.ts

@@ -0,0 +1,299 @@
+/**
+ * Built-in lightweight schema validator & Standard Schema v1 (ArkType, Zod, Valibot) support
+ */
+
+export interface ValidationIssue {
+  path: string;
+  message: string;
+}
+
+export interface ValidationResult<T> {
+  success: boolean;
+  data?: T;
+  issues?: ValidationIssue[];
+}
+
+export interface StandardSchemaV1<T = any> {
+  "~standard": {
+    version: 1;
+    vendor: string;
+    validate: (value: unknown) =>
+      | { value: T }
+      | {
+          issues: ReadonlyArray<{
+            path?: ReadonlyArray<string | number>;
+            message: string;
+          }>;
+        };
+  };
+}
+
+export type SchemaLike<T = any> =
+  | Schema<T>
+  | StandardSchemaV1<T>
+  | ((value: unknown) => ValidationResult<T> | boolean | string | null | undefined);
+
+export abstract class Schema<T = any> {
+  declare readonly _type: T;
+  abstract validate(value: unknown, path?: string): ValidationResult<T>;
+
+  // Standard Schema v1 specification compatibility
+  "~standard" = {
+    version: 1 as const,
+    vendor: "visage",
+    validate: (val: unknown) => {
+      const res = this.validate(val);
+      if (res.success) {
+        return { value: res.data as T };
+      }
+      return {
+        issues: (res.issues || []).map((i) => ({
+          path: [i.path],
+          message: i.message
+        }))
+      };
+    }
+  };
+}
+
+class StringSchema extends Schema<string> {
+  private _min?: { val: number; msg?: string };
+  private _max?: { val: number; msg?: string };
+  private _emailMsg?: string;
+  private _regex?: { pattern: RegExp; msg?: string };
+  private _isOptional = false;
+
+  min(length: number, message?: string): this {
+    this._min = { val: length, msg: message };
+    return this;
+  }
+
+  max(length: number, message?: string): this {
+    this._max = { val: length, msg: message };
+    return this;
+  }
+
+  email(message?: string): this {
+    this._emailMsg = message ?? "Invalid email address";
+    return this;
+  }
+
+  regex(pattern: RegExp, message?: string): this {
+    this._regex = { pattern, msg: message };
+    return this;
+  }
+
+  optional(): Schema<string | undefined> {
+    this._isOptional = true;
+    return this as any;
+  }
+
+  validate(value: unknown, path = ""): ValidationResult<string> {
+    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<number> {
+  private _min?: { val: number; msg?: string };
+  private _max?: { val: number; msg?: string };
+  private _integer?: { msg?: string };
+  private _isOptional = false;
+
+  min(value: number, message?: string): this {
+    this._min = { val: value, msg: message };
+    return this;
+  }
+
+  max(value: number, message?: string): this {
+    this._max = { val: value, msg: message };
+    return this;
+  }
+
+  integer(message?: string): this {
+    this._integer = { msg: message };
+    return this;
+  }
+
+  optional(): Schema<number | undefined> {
+    this._isOptional = true;
+    return this as any;
+  }
+
+  validate(value: unknown, path = ""): ValidationResult<number> {
+    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<boolean> {
+  validate(value: unknown, _path = ""): ValidationResult<boolean> {
+    return { success: true, data: Boolean(value) };
+  }
+}
+
+export type InferSchemaType<S> =
+  S extends Schema<infer T>
+    ? T
+    : S extends StandardSchemaV1<infer T>
+      ? T
+      : S extends (val: any) => ValidationResult<infer T>
+        ? T
+        : any;
+
+export type InferObjectShape<S extends Record<string, SchemaLike<any>>> = {
+  [K in keyof S]: InferSchemaType<S[K]>;
+};
+
+export class ObjectSchema<T extends Record<string, any>> extends Schema<T> {
+  constructor(public shape: { [K in keyof T]: SchemaLike<T[K]> }) {
+    super();
+  }
+
+  validate(value: unknown, basePath = ""): ValidationResult<T> {
+    if (typeof value !== "object" || value === null) {
+      return { success: false, issues: [{ path: basePath, message: "Must be an object" }] };
+    }
+
+    const issues: ValidationIssue[] = [];
+    const data: Record<string, any> = {};
+
+    for (const key in this.shape) {
+      const fieldSchema = this.shape[key]!;
+      const fieldVal = (value as any)[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: data as T };
+  }
+}
+
+export function validateWithSchema<T>(
+  schema: SchemaLike<T>,
+  value: unknown,
+  path = ""
+): ValidationResult<T> {
+  if (!schema) return { success: true, data: value as T };
+
+  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 as T };
+    }
+    if (typeof res === "string") {
+      return { success: false, issues: [{ path, message: res }] };
+    }
+    if (typeof res === "object") {
+      return res as ValidationResult<T>;
+    }
+  }
+
+  return { success: true, data: value as T };
+}
+
+/**
+ * Built-in schema definition library
+ */
+export const v = {
+  string: () => new StringSchema(),
+  number: () => new NumberSchema(),
+  boolean: () => new BooleanSchema(),
+  object: <S extends Record<string, SchemaLike<any>>>(
+    shape: S
+  ): ObjectSchema<{ [K in keyof S]: InferSchemaType<S[K]> }> => new ObjectSchema(shape as any)
+};

package/src/index.ts

@@ -0,0 +1,413 @@
+// Reactive Primitives
+
+// File-Based API & Opinionated RPC
+export {
+  type ApiClient,
+  type ApiClientOptions,
+  buildFileRouter,
+  createApi,
+  createApiClient,
+  createApiHandler,
+  defineMiddleware,
+  type FileRouteModule,
+  ProcedureBuilder,
+  procedure
+} from "./api";
+// Composable Fine-Grained Reactive Charts
+export {
+  type AnyScale,
+  Area,
+  type AreaProps,
+  type BandScale,
+  Bar,
+  type BarProps,
+  CartesianGrid,
+  type CartesianGridProps,
+  Chart,
+  ChartContext,
+  type ChartContextValue,
+  ChartCursor,
+  type ChartCursorProps,
+  ChartLegend,
+  type ChartProps,
+  ChartTooltip,
+  type CurveType,
+  createBandScale,
+  createLinearScale,
+  generateNiceTicks,
+  type HoverState,
+  Legend,
+  type LegendProps,
+  Line,
+  type LinearScale,
+  type LineProps,
+  type Margin,
+  Pie,
+  type PieProps,
+  type Point,
+  pathArc,
+  pathArea,
+  pathLine,
+  type SeriesMeta,
+  useChartContext,
+  XAxis,
+  type XAxisProps,
+  YAxis,
+  type YAxisProps
+} from "./charts";
+// In-Browser DevTools & Visual Inspector
+export {
+  connectDevTools,
+  DevToolsHub,
+  type DevToolsOptions,
+  type DevToolsTab,
+  devtoolsHub,
+  highlightElement,
+  type QueryRecord,
+  type RpcRecord,
+  type SignalRecord,
+  VisageDevTools
+} from "./devtools";
+// DOM & Mount Primitives
+export {
+  type Child,
+  type Component,
+  createResource,
+  ErrorBoundary,
+  type ErrorBoundaryProps,
+  For,
+  type ForProps,
+  insertChild,
+  isReactive,
+  type LazyComponent,
+  lazy,
+  Portal,
+  type PortalProps,
+  type ReactiveValue,
+  type Resource,
+  type ResourceActions,
+  render,
+  resolveValue,
+  Show,
+  type ShowProps,
+  Suspense,
+  type SuspenseProps,
+  setAttribute
+} from "./dom";
+// Reactive Forms & Schema Validation
+export {
+  createForm,
+  type FieldState,
+  type Form,
+  type FormFields,
+  type FormOptions,
+  Schema,
+  type SchemaLike,
+  type StandardSchemaV1,
+  type ValidationIssue,
+  type ValidationResult,
+  v,
+  validateWithSchema
+} from "./form";
+// JSX Typings
+export type {
+  AnchorAttributes,
+  ButtonAttributes,
+  HTMLAttributes,
+  InputAttributes,
+  JSX,
+  ReactiveProp
+} from "./jsx-runtime/jsx";
+// Query & Server State Cache
+export {
+  type CreateQueryOptions,
+  createInfiniteQuery,
+  createMutation,
+  createQuery,
+  type DefaultOptions,
+  type FetchStatus,
+  FocusManager,
+  focusManager,
+  hashKey,
+  type InfiniteData,
+  type InfiniteQueryOptions,
+  type InfiniteQueryResult,
+  type MutateOptions,
+  Mutation,
+  MutationCache,
+  type MutationFunction,
+  type MutationOptions,
+  type MutationResult,
+  type MutationStatus,
+  OnlineManager,
+  onlineManager,
+  Query,
+  QueryCache,
+  QueryClient,
+  type QueryClientConfig,
+  QueryClientContext,
+  QueryClientProvider,
+  type QueryFilters,
+  type QueryFunction,
+  type QueryFunctionContext,
+  type QueryKey,
+  type QueryObserver,
+  type QueryOptions,
+  type QueryResult,
+  type QueryState,
+  type QueryStatus,
+  type RefetchOptions,
+  type RetryDelayValue
+} from "./query";
+// Router Primitives
+export {
+  Link,
+  type LinkProps,
+  type LocationState,
+  type MatchedRoute,
+  Route,
+  type RouteDefinition,
+  type RouteProps,
+  Router,
+  type RouterContextValue,
+  type RouterProps,
+  Routes,
+  type RoutesProps,
+  useLocation,
+  useNavigate,
+  useParams,
+  useSearchParams
+} from "./router";
+// Type-Safe Wire RPC & APIs
+export {
+  type ClientOptions,
+  type ClientRouter,
+  type CORSOptions,
+  createClient,
+  createFetchHandler,
+  createProcedure,
+  createRouter,
+  ERROR_CODE_TO_STATUS,
+  executeProcedure,
+  type FetchHandlerOptions,
+  type MiddlewareFn,
+  mutation,
+  type Procedure,
+  type ProcedureOptions,
+  type ProcedureRecord,
+  type ProcedureType,
+  query,
+  type Router as RPCRouter,
+  RouterImpl,
+  RPCError,
+  type RPCErrorCode,
+  type RPCResponse,
+  STATUS_TO_ERROR_CODE,
+  type SubscriptionCallbacks,
+  type SubscriptionHandle,
+  subscription
+} from "./rpc";
+// Server-Side Rendering & Hydration
+export {
+  hydrate,
+  renderChildToString,
+  renderToStream,
+  renderToString,
+  type StreamOptions
+} from "./server";
+export {
+  batch,
+  type CleanupFn,
+  Computed,
+  type Context,
+  computed,
+  createContext,
+  createEffect,
+  createMemo,
+  createRoot,
+  createSignal,
+  createStore,
+  type Dependency,
+  Effect,
+  effect,
+  getActiveScope,
+  isSignal,
+  mutateStore,
+  onCleanup,
+  type ReadonlySignal,
+  runInScope,
+  Scope,
+  Signal,
+  type Store,
+  type Subscriber,
+  signal,
+  untrack,
+  unwrapStore,
+  useContext,
+  type WritableSignal
+} from "./signals";
+// Scoped Styles & CSS Engine
+// Spatial Engine & Semantic Layout Primitives
+export {
+  type BaseLayoutProps,
+  Center,
+  type CenterProps,
+  type ClassValue,
+  createStyle,
+  css,
+  cx,
+  DIMENSION_KEYWORDS,
+  em,
+  extractStyleTags,
+  fluid,
+  formatStyleProp,
+  type GlassOptions,
+  Grid,
+  type GridProps,
+  getScopeId,
+  glass,
+  hashString,
+  hasReactiveClass,
+  normalizeClass,
+  px,
+  type RadiusVariant,
+  Row,
+  type RowProps,
+  radius,
+  rem,
+  type ScopeOptions,
+  type ShadowVariant,
+  Spacer,
+  type SpacerProps,
+  Stack,
+  type StackProps,
+  Style,
+  type StyleClasses,
+  StyleManager,
+  type StyleProps,
+  scopeCSS,
+  scopeSelector,
+  shadow,
+  space,
+  styleManager,
+  UNITLESS_PROPERTIES,
+  useStyle
+} from "./style";
+// Template HTML Cloning & Tagged Template
+export {
+  html,
+  template
+} from "./template";
+// Headless Accessible UI Component Primitives
+export {
+  Accordion,
+  AccordionContent,
+  AccordionItem,
+  type AccordionItemProps,
+  type AccordionMultipleProps,
+  type AccordionProps,
+  type AccordionSingleProps,
+  AccordionTrigger,
+  type ColumnDef,
+  Command,
+  CommandDialog,
+  type CommandDialogProps,
+  CommandEmpty,
+  CommandGroup,
+  type CommandGroupData,
+  CommandInput,
+  type CommandInputProps,
+  CommandItem,
+  type CommandItemData,
+  type CommandItemProps,
+  CommandList,
+  type CommandProps,
+  createControllableSignal,
+  createIcon,
+  createId,
+  createToastManager,
+  DataTable,
+  type DataTableProps,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  type DialogContentProps,
+  DialogDescription,
+  DialogOverlay,
+  DialogPortal,
+  type DialogProps,
+  DialogTitle,
+  DialogTrigger,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  type DropdownMenuItemProps,
+  DropdownMenuPortal,
+  type DropdownMenuProps,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  defaultToastManager,
+  type IconNode,
+  type IconProps,
+  onClickOutside,
+  Popover,
+  PopoverClose,
+  PopoverContent,
+  type PopoverContentProps,
+  PopoverPortal,
+  type PopoverProps,
+  PopoverTrigger,
+  type SortDirection,
+  type SortState,
+  Switch,
+  type SwitchProps,
+  SwitchThumb,
+  type SwitchThumbProps,
+  Tabs,
+  TabsContent,
+  type TabsContentProps,
+  TabsList,
+  type TabsProps,
+  TabsTrigger,
+  Toast,
+  ToastClose,
+  type ToastData,
+  ToastDescription,
+  type ToastManager,
+  type ToastOptions,
+  type ToastProps,
+  ToastProvider,
+  type ToastProviderProps,
+  ToastTitle,
+  type ToastVariant,
+  ToastViewport,
+  type ToastViewportProps,
+  Tooltip,
+  TooltipContent,
+  type TooltipContentProps,
+  TooltipPortal,
+  type TooltipProps,
+  TooltipTrigger,
+  toast,
+  trapFocus,
+  useAccordionContext,
+  useAccordionItemContext,
+  useCommandContext,
+  useDialogContext,
+  useDropdownMenuContext,
+  usePopoverContext,
+  useTabsContext,
+  useToast,
+  useTooltipContext
+} from "./ui";
+// Virtual List & Grid Virtualization
+export {
+  createVirtualizer,
+  VirtualGrid,
+  type VirtualGridProps,
+  type VirtualItem,
+  type Virtualizer,
+  type VirtualizerOptions,
+  VirtualList,
+  type VirtualListProps
+} from "./virtual";

package/src/jsx-dev-runtime/index.ts

@@ -0,0 +1 @@
+export { Fragment, type JSX, jsx, jsxDEV, jsxs } from "../jsx-runtime";