@fynixorg/ui 1.0.0

package/runtime.d.ts

@@ -0,0 +1,83 @@
+// Type definitions for Fynix Runtime
+// This file provides TypeScript support for the Fynix framework
+
+/// <reference path="./types/jsx.d.ts" />
+/// <reference path="./types/global.d.ts" />
+
+export const TEXT: unique symbol;
+export const Fragment: unique symbol;
+
+export interface VNode {
+  type: string | symbol | ((props: any) => any);
+  props: Record<string, any>;
+  key: string | number | null;
+  _domNode?: Node;
+  _rendered?: VNode;
+  _state?: any;
+}
+
+export type Element = 
+  | VNode
+  | string 
+  | number 
+  | boolean 
+  | null 
+  | undefined
+  | Element[];
+
+export type ComponentFunction<P = {}> = (props: P) => Element;
+
+export function Fynix(
+  type: string | symbol | ComponentFunction,
+  props?: Record<string, any> | null,
+  ...children: any[]
+): VNode;
+
+export namespace Fynix {
+  export function Fragment(props: { children?: any }): any;
+}
+
+export const h: typeof Fynix;
+
+export function createTextVNode(text: string | number | any): VNode;
+
+export function mount(
+  AppComponent: ComponentFunction,
+  root: string | Element,
+  hydrate?: boolean,
+  props?: Record<string, any>
+): void;
+
+export function renderComponent(
+  Component: ComponentFunction,
+  props?: Record<string, any>
+): VNode;
+
+// Hooks
+export function nixState<T>(initialValue: T): any;
+export function nixStore<T extends Record<string, any>>(initialState: T): any;
+export function nixComputed<T>(fn: () => T): any;
+export function nixRef<T = any>(initial?: T): { current: T };
+export function nixEffect(fn: () => void | (() => void), deps?: any[]): void;
+export function nixEffectAlways(fn: () => void | (() => void)): void;
+export function nixEffectOnce(fn: () => void | (() => void)): void;
+export function nixInterval(callback: () => void, delay: number): void;
+export function nixMemo<T>(fn: () => T, deps?: any[]): T;
+export function nixCallback<T extends (...args: any[]) => any>(fn: T, deps?: any[]): T;
+export function nixPrevious<T>(value: T): T | undefined;
+export function nixAsync<T>(fn: (signal: AbortSignal) => Promise<T>): any;
+export function nixAsyncCached<T>(fn: () => Promise<T>, cacheKey?: string): any;
+export function nixAsyncDebounce<T>(fn: () => Promise<T>, delay: number): any;
+export function nixAsyncQuery<T>(queryKey: any, queryFn: () => Promise<T>, options?: any): any;
+export function nixDebounce<T extends (...args: any[]) => any>(fn: T, delay: number): T;
+export function nixLocalStorage<T>(key: string, initialValue: T): any;
+export function nixLazy(loader: () => Promise<any>): any;
+export function nixLazyAsync(loader: () => Promise<any>): any;
+export function nixForm<T extends Record<string, any>>(initialValues: T, options?: any): any;
+export function nixFormAsync<T extends Record<string, any>>(initialValues: T, options?: any): any;
+export function nixLazyFormAsync<T extends Record<string, any>>(loader: () => Promise<any>, options?: any): any;
+
+// Components
+export const Suspense: any;
+export const Path: any;
+export const Button: any;

package/types/global.d.ts

@@ -0,0 +1,236 @@
+// global.d.ts - Fynix Global Type Declarations
+
+/**
+ * Reactive state object
+ */
+interface NixState<T> {
+  value: T;
+  _isNixState: true;
+  subscribe(callback: () => void): () => void;
+}
+
+/**
+ * Reactive store object
+ */
+interface NixStore<T extends Record<string, any>> {
+  _isNixStore: true;
+  subscribe(callback: () => void): () => void;
+  getState(): T;
+  setState(updates: Partial<T> | ((state: T) => Partial<T>)): void;
+  [key: string]: any;
+}
+
+/**
+ * Async state result
+ */
+interface NixAsyncResult<T> {
+  data: T | null;
+  loading: boolean;
+  error: Error | null;
+  refetch: () => Promise<void>;
+}
+
+/**
+ * Form field
+ */
+interface NixFormField<T = any> {
+  value: T;
+  error: string | null;
+  touched: boolean;
+}
+
+/**
+ * Form state
+ */
+interface NixFormState<T extends Record<string, any>> {
+  values: { [K in keyof T]: NixFormField<T[K]> };
+  isValid: boolean;
+  isSubmitting: boolean;
+  errors: { [K in keyof T]?: string };
+  handleSubmit: (onSubmit: (values: T) => void | Promise<void>) => (e?: Event) => Promise<void>;
+  reset: () => void;
+  setFieldValue: <K extends keyof T>(field: K, value: T[K]) => void;
+  setFieldError: <K extends keyof T>(field: K, error: string) => void;
+}
+
+/**
+ * Lazy component result
+ */
+interface NixLazyComponent {
+  Component: any;
+  loading: boolean;
+  error: Error | null;
+}
+
+/**
+ * Fynix Router instance
+ */
+interface FynixRouter {
+  mountRouter(selector?: string): void;
+  navigate(path: string, props?: Record<string, any>): void;
+  replace(path: string, props?: Record<string, any>): void;
+  back(): void;
+  cleanup(): void;
+  routes: Record<string, any>;
+  dynamicRoutes: Array<{
+    pattern: string;
+    regex: RegExp;
+    component: any;
+    params: string[];
+  }>;
+}
+
+/**
+ * Window object extensions for Fynix framework
+ */
+interface Window {
+  /** Cache for router props to prevent memory leaks */
+  __fynixPropsCache?: Map<string, any>;
+  
+  /** Link props namespace for router navigation */
+  __fynixLinkProps__?: Record<string, any>;
+  
+  /** Last route props passed to components */
+  __lastRouteProps?: any;
+  
+  /** Fynix global state and utilities */
+  __fynix__?: {
+    /** Current route props */
+    lastRouteProps?: any;
+    /** Force re-render function */
+    rerender?: () => void;
+    /** Hot Module Replacement handler */
+    hmr?: (ctx: { mod: any }) => void;
+  };
+}
+
+/**
+ * HTMLElement extensions for event delegation and Fynix internals
+ */
+interface HTMLElement {
+  /** Event delegation ID for r-* event handlers */
+  _rest_eid?: number;
+  
+  /** Fynix internal data storage */
+  _fynix_?: any;
+}
+
+/**
+ * Node extensions for Fynix virtual DOM
+ */
+interface Node {
+  /** Event delegation ID */
+  _rest_eid?: number;
+  /** Fynix cleanup functions */
+  _fynixCleanups?: Array<() => void>;
+}
+
+/**
+ * Text node type with nodeValue
+ */
+interface Text {
+  nodeValue: string | null;
+}
+
+/**
+ * Vite-specific import.meta extensions
+ */
+interface ImportMeta {
+  /** Vite Hot Module Replacement API */
+  readonly hot?: {
+    /** Accept HMR updates */
+    accept: (cb?: (mod: any) => void) => void;
+    /** Cleanup before module disposal */
+    dispose: (cb: () => void) => void;
+    /** Decline HMR for this module */
+    decline?: () => void;
+    /** Invalidate and force full reload */
+    invalidate?: () => void;
+    /** Custom HMR event handling */
+    on?: (event: string, cb: (...args: any[]) => void) => void;
+  };
+  
+  /** Vite glob import function */
+  readonly glob: <T = any>(
+    pattern: string,
+    options?: {
+      /** Load modules eagerly (at build time) */
+      eager?: boolean;
+      /** Import as URL strings */
+      as?: 'url' | 'raw';
+      /** Custom import query */
+      query?: Record<string, string | number | boolean>;
+    }
+  ) => Record<string, T>;
+  
+  /** Environment variables */
+  readonly env: {
+    MODE: string;
+    BASE_URL: string;
+    PROD: boolean;
+    DEV: boolean;
+    SSR: boolean;
+    [key: string]: any;
+  };
+}
+
+/**
+ * Module declarations for non-TypeScript files
+ */
+declare module '*.css' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.scss' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.svg' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.png' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.jpg' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.jpeg' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.gif' {
+  const content: string;
+  export default content;
+}
+
+declare module '*.webp' {
+  const content: string;
+  export default content;
+}
+
+/**
+ * Fynix-specific module patterns
+ */
+declare module '*.fnx' {
+  const Component: any;
+  export default Component;
+}
+
+declare module '*.js' {
+  const Component: any;
+  export default Component;
+}
+
+/**
+ * Vite client types
+ */
+/// <reference types="vite/client" />