@epoch32/visage 0.0.0-stage → 0.0.0

package/src/query/types.ts

@@ -0,0 +1,221 @@
+import type { ReadonlySignal } from "../signals";
+
+export type QueryKey = readonly unknown[];
+
+export interface QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = any> {
+  queryKey: TQueryKey;
+  signal: AbortSignal;
+  pageParam?: TPageParam;
+  meta?: Record<string, unknown>;
+}
+
+export type QueryFunction<
+  TData = unknown,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = any
+> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<TData> | TData;
+
+export type QueryStatus = "pending" | "success" | "error";
+export type FetchStatus = "fetching" | "paused" | "idle";
+export type MutationStatus = "idle" | "pending" | "success" | "error";
+
+export type RetryValue = boolean | number | ((failureCount: number, error: any) => boolean);
+export type RetryDelayValue = number | ((attemptIndex: number, error: any) => number);
+
+export interface QueryFilters {
+  queryKey?: QueryKey;
+  exact?: boolean;
+  type?: "all" | "active" | "inactive";
+  stale?: boolean;
+  fetchStatus?: FetchStatus;
+  predicate?: (query: any) => boolean;
+}
+
+export interface QueryState<TData = unknown, TError = any> {
+  data: TData | undefined;
+  error: TError | null;
+  status: QueryStatus;
+  fetchStatus: FetchStatus;
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  isInvalidated: boolean;
+}
+
+export interface QueryOptions<
+  TData = unknown,
+  _TError = any,
+  TQueryKey extends QueryKey = QueryKey
+> {
+  queryKey: TQueryKey;
+  queryFn?: QueryFunction<TData, TQueryKey>;
+  enabled?: boolean | (() => boolean);
+  staleTime?: number;
+  gcTime?: number;
+  retry?: RetryValue;
+  retryDelay?: RetryDelayValue;
+  refetchInterval?: number | false | (() => number | false);
+  refetchIntervalInBackground?: boolean;
+  refetchOnWindowFocus?: boolean | "always";
+  refetchOnReconnect?: boolean | "always";
+  initialData?: TData | (() => TData);
+  initialDataUpdatedAt?: number | (() => number);
+  placeholderData?: TData | ((previousData: TData | undefined) => TData);
+  meta?: Record<string, unknown>;
+}
+
+export interface CreateQueryOptions<
+  TData = unknown,
+  TError = any,
+  TSelected = TData,
+  TQueryKey extends QueryKey = QueryKey
+> extends QueryOptions<TData, TError, TQueryKey> {
+  select?: (data: TData) => TSelected;
+  suspense?: boolean;
+}
+
+export interface RefetchOptions {
+  throwOnError?: boolean;
+  cancelRefetch?: boolean;
+}
+
+export interface QueryResult<TData = unknown, TError = any> {
+  data: ReadonlySignal<TData | undefined>;
+  error: ReadonlySignal<TError | null>;
+  status: ReadonlySignal<QueryStatus>;
+  fetchStatus: ReadonlySignal<FetchStatus>;
+  isLoading: ReadonlySignal<boolean>;
+  isFetching: ReadonlySignal<boolean>;
+  isSuccess: ReadonlySignal<boolean>;
+  isError: ReadonlySignal<boolean>;
+  isStale: ReadonlySignal<boolean>;
+  dataUpdatedAt: ReadonlySignal<number>;
+  errorUpdatedAt: ReadonlySignal<number>;
+  refetch: (options?: RefetchOptions) => Promise<TData | undefined>;
+  (): TData | undefined;
+}
+
+export type MutationFunction<TData = unknown, TVariables = void> = (
+  variables: TVariables
+) => Promise<TData>;
+
+export interface MutationOptions<
+  TData = unknown,
+  TError = any,
+  TVariables = void,
+  TContext = unknown
+> {
+  mutationKey?: QueryKey;
+  mutationFn: MutationFunction<TData, TVariables>;
+  onMutate?: (variables: TVariables) => Promise<TContext | void> | TContext | void;
+  onSuccess?: (
+    data: TData,
+    variables: TVariables,
+    context: TContext | undefined
+  ) => Promise<void> | void;
+  onError?: (
+    error: TError,
+    variables: TVariables,
+    context: TContext | undefined
+  ) => Promise<void> | void;
+  onSettled?: (
+    data: TData | undefined,
+    error: TError | null,
+    variables: TVariables,
+    context: TContext | undefined
+  ) => Promise<void> | void;
+  retry?: RetryValue;
+  retryDelay?: RetryDelayValue;
+  meta?: Record<string, unknown>;
+}
+
+export interface MutateOptions<
+  TData = unknown,
+  TError = any,
+  TVariables = void,
+  TContext = unknown
+> {
+  onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => void;
+  onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void;
+  onSettled?: (
+    data: TData | undefined,
+    error: TError | null,
+    variables: TVariables,
+    context: TContext | undefined
+  ) => void;
+}
+
+export interface MutationResult<
+  TData = unknown,
+  TError = any,
+  TVariables = void,
+  TContext = unknown
+> {
+  mutate: (
+    variables: TVariables,
+    options?: MutateOptions<TData, TError, TVariables, TContext>
+  ) => void;
+  mutateAsync: (
+    variables: TVariables,
+    options?: MutateOptions<TData, TError, TVariables, TContext>
+  ) => Promise<TData>;
+  data: ReadonlySignal<TData | undefined>;
+  error: ReadonlySignal<TError | null>;
+  status: ReadonlySignal<MutationStatus>;
+  isIdle: ReadonlySignal<boolean>;
+  isPending: ReadonlySignal<boolean>;
+  isLoading: ReadonlySignal<boolean>;
+  isSuccess: ReadonlySignal<boolean>;
+  isError: ReadonlySignal<boolean>;
+  reset: () => void;
+  variables: ReadonlySignal<TVariables | undefined>;
+  submittedAt: ReadonlySignal<number>;
+  (): TData | undefined;
+}
+
+export interface InfiniteData<TData = unknown, TPageParam = unknown> {
+  pages: TData[];
+  pageParams: TPageParam[];
+}
+
+export interface InfiniteQueryOptions<
+  TData = unknown,
+  TError = any,
+  TPageParam = unknown,
+  TSelected = InfiniteData<TData, TPageParam>,
+  TQueryKey extends QueryKey = QueryKey
+> extends Omit<QueryOptions<InfiniteData<TData, TPageParam>, TError, TQueryKey>, "queryFn"> {
+  queryFn?: (context: QueryFunctionContext<TQueryKey, TPageParam>) => Promise<TData> | TData;
+  initialPageParam: TPageParam;
+  getNextPageParam: (
+    lastPage: TData,
+    allPages: TData[],
+    lastPageParam: TPageParam,
+    allPageParams: TPageParam[]
+  ) => TPageParam | undefined | null;
+  getPreviousPageParam?: (
+    firstPage: TData,
+    allPages: TData[],
+    firstPageParam: TPageParam,
+    allPageParams: TPageParam[]
+  ) => TPageParam | undefined | null;
+  maxPages?: number;
+  select?: (data: InfiniteData<TData, TPageParam>) => TSelected;
+  suspense?: boolean;
+}
+
+export interface InfiniteQueryResult<TData = unknown, TError = any, TPageParam = unknown>
+  extends Omit<QueryResult<InfiniteData<TData, TPageParam>, TError>, "refetch"> {
+  fetchNextPage: () => Promise<InfiniteData<TData, TPageParam> | undefined>;
+  fetchPreviousPage: () => Promise<InfiniteData<TData, TPageParam> | undefined>;
+  hasNextPage: ReadonlySignal<boolean>;
+  hasPreviousPage: ReadonlySignal<boolean>;
+  isFetchingNextPage: ReadonlySignal<boolean>;
+  isFetchingPreviousPage: ReadonlySignal<boolean>;
+  refetch: (options?: RefetchOptions) => Promise<InfiniteData<TData, TPageParam> | undefined>;
+}
+
+export interface DefaultOptions {
+  queries?: Partial<QueryOptions<any, any, any>>;
+  mutations?: Partial<MutationOptions<any, any, any, any>>;
+}

package/src/query/utils.ts

@@ -0,0 +1,132 @@
+import type { QueryFilters } from "./types";
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+
+/**
+ * Deterministic JSON stringifier for consistent query key hashing
+ */
+export function hashKey(queryKey: unknown): string {
+  return JSON.stringify(queryKey, (_key, val) => {
+    if (isPlainObject(val)) {
+      return Object.keys(val)
+        .sort()
+        .reduce((result: Record<string, unknown>, k) => {
+          result[k] = val[k];
+          return result;
+        }, {});
+    }
+    return val;
+  });
+}
+
+/**
+ * Deep equality check for primitives, arrays, and objects
+ */
+export function deepEqual(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  const keysA = Object.keys(a as Record<string, unknown>);
+  const keysB = Object.keys(b as Record<string, unknown>);
+
+  if (keysA.length !== keysB.length) return false;
+
+  for (const key of keysA) {
+    if (!Object.hasOwn(b, key)) return false;
+    if (!deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Partial matching check: matches if `a` is a subset or partial structure of `b`
+ */
+export function partialDeepEqual(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (a === undefined || a === null || b === undefined || b === null) {
+    return a === b;
+  }
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length > b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!partialDeepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  if (isPlainObject(a) && isPlainObject(b)) {
+    for (const key of Object.keys(a)) {
+      if (!(key in b)) return false;
+      if (!partialDeepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+
+export function matchQuery(filters: QueryFilters | undefined, query: any): boolean {
+  if (!filters) return true;
+
+  if (filters.queryKey !== undefined) {
+    const filterKey = Array.isArray(filters.queryKey) ? filters.queryKey : [filters.queryKey];
+    const queryKey = Array.isArray(query.queryKey) ? query.queryKey : [query.queryKey];
+
+    if (filters.exact) {
+      if (filterKey.length !== queryKey.length) return false;
+      if (!deepEqual(filterKey, queryKey)) return false;
+    } else {
+      if (filterKey.length > queryKey.length) return false;
+      for (let i = 0; i < filterKey.length; i++) {
+        if (!partialDeepEqual(filterKey[i], queryKey[i])) {
+          return false;
+        }
+      }
+    }
+  }
+
+  if (filters.type === "active" && query.observers.size === 0) {
+    return false;
+  }
+  if (filters.type === "inactive" && query.observers.size > 0) {
+    return false;
+  }
+
+  if (filters.stale !== undefined && query.isStale() !== filters.stale) {
+    return false;
+  }
+
+  if (filters.fetchStatus !== undefined && query.fetchStatus() !== filters.fetchStatus) {
+    return false;
+  }
+
+  if (filters.predicate && !filters.predicate(query)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/router/index.ts

@@ -0,0 +1,19 @@
+export {
+  Link,
+  type LinkProps,
+  type LocationState,
+  lazy,
+  type MatchedRoute,
+  Route,
+  type RouteDefinition,
+  type RouteProps,
+  Router,
+  type RouterContextValue,
+  type RouterProps,
+  Routes,
+  type RoutesProps,
+  useLocation,
+  useNavigate,
+  useParams,
+  useSearchParams
+} from "./router";