fiboui 1.0.0

package/src/core/state.ts

@@ -0,0 +1,233 @@
+
+
+
+
+
+
+export type StateGetter<T> = () => T;
+export type StateSetter<T> = (value: T | ((prev: T) => T)) => void;
+export type StateHook<T> = [T, StateSetter<T>];
+
+
+
+
+
+export interface Signal<T> {
+  value: T;
+  subscribe(callback: (value: T) => void): () => void;
+}
+
+export interface ComputedSignal<T> extends Omit<Signal<T>, 'value'> {
+  readonly value: T;
+}
+
+type EffectCleanup = void | (() => void);
+
+
+class SignalImpl<T> implements Signal<T> {
+  private _value: T;
+  private subscribers = new Set<(value: T) => void>();
+
+  constructor(initialValue: T) {
+    this._value = initialValue;
+  }
+
+  get value(): T {
+    return this._value;
+  }
+
+  set value(newValue: T) {
+    if (this._value !== newValue) {
+      this._value = newValue;
+      this.notify();
+    }
+  }
+
+  subscribe(callback: (value: T) => void): () => void {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+
+  private notify() {
+    this.subscribers.forEach(callback => callback(this._value));
+  }
+}
+
+
+class ComputedSignalImpl<T> implements ComputedSignal<T> {
+  private _value: T;
+  private subscribers = new Set<(value: T) => void>();
+  private dependencies = new Set<Signal<any>>();
+  private unsubscribers: (() => void)[] = [];
+
+  constructor(private compute: () => T) {
+    this._value = this.recompute();
+  }
+
+  get value(): T {
+    return this._value;
+  }
+
+  subscribe(callback: (value: T) => void): () => void {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+
+  private recompute(): T {
+    
+    this.unsubscribers.forEach(unsub => unsub());
+    this.unsubscribers = [];
+    this.dependencies.clear();
+
+    
+    const newValue = this.compute();
+    
+    if (this._value !== newValue) {
+      this._value = newValue;
+      this.notify();
+    }
+
+    return newValue;
+  }
+
+  private notify() {
+    this.subscribers.forEach(callback => callback(this._value));
+  }
+}
+
+
+export function signal<T>(initialValue: T): Signal<T> {
+  return new SignalImpl(initialValue);
+}
+
+
+export function computed<T>(fn: () => T): ComputedSignal<T> {
+  return new ComputedSignalImpl(fn);
+}
+
+
+export function effect(fn: () => EffectCleanup): () => void {
+  let cleanup: EffectCleanup;
+  
+  const run = () => {
+    if (typeof cleanup === 'function') {
+      cleanup();
+    }
+    cleanup = fn();
+  };
+
+  run(); 
+  
+  return () => {
+    if (typeof cleanup === 'function') {
+      cleanup();
+    }
+  };
+}
+
+
+
+
+
+export interface Observable<T> {
+  get(): T;
+  set(value: T): void;
+  subscribe(listener: (value: T) => void): () => void;
+}
+
+class ObservableImpl<T> implements Observable<T> {
+  private _value: T;
+  private listeners = new Set<(value: T) => void>();
+
+  constructor(initialValue: T) {
+    this._value = initialValue;
+  }
+
+  get(): T {
+    return this._value;
+  }
+
+  set(value: T): void {
+    if (this._value !== value) {
+      this._value = value;
+      this.listeners.forEach(listener => listener(value));
+    }
+  }
+
+  subscribe(listener: (value: T) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+}
+
+
+export function observable<T>(initialValue: T): Observable<T> {
+  return new ObservableImpl(initialValue);
+}
+
+
+
+
+
+export interface Store<T> {
+  getState(): T;
+  setState(updater: Partial<T> | ((state: T) => Partial<T>)): void;
+  subscribe(listener: (state: T) => void): () => void;
+}
+
+class StoreImpl<T> implements Store<T> {
+  private state: T;
+  private listeners = new Set<(state: T) => void>();
+
+  constructor(initialState: T) {
+    this.state = initialState;
+  }
+
+  getState(): T {
+    return this.state;
+  }
+
+  setState(updater: Partial<T> | ((state: T) => Partial<T>)): void {
+    const updates = typeof updater === 'function' ? updater(this.state) : updater;
+    this.state = { ...this.state, ...updates };
+    this.listeners.forEach(listener => listener(this.state));
+  }
+
+  subscribe(listener: (state: T) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+}
+
+
+export function createStore<T extends object>(initialState: T): Store<T> {
+  return new StoreImpl(initialState);
+}
+
+
+
+
+
+export interface ProviderConfig<T = any> {
+  key: string;
+  value: T;
+}
+
+export interface ConsumerConfig {
+  key: string;
+}
+
+
+const providerRegistry = new Map<string, any>();
+
+export function registerProvider<T>(key: string, value: T): void {
+  providerRegistry.set(key, value);
+}
+
+export function getProvider<T>(key: string): T | undefined {
+  return providerRegistry.get(key);
+}
+
+export function clearProviders(): void {
+  providerRegistry.clear();
+}

package/src/core/types.ts

@@ -0,0 +1,62 @@
+import { CSSProperties, ReactNode, ReactElement } from 'react';
+
+export type FiboThemeName = 'material' | 'cupertino' | 'web';
+
+export interface ResponsiveStyles {
+  mobile?: CSSProperties;
+  tablet?: CSSProperties;
+  desktop?: CSSProperties;
+}
+
+export interface BaseProps {
+  key?: string | number;
+  className?: string;
+  style?: CSSProperties;
+  responsive?: ResponsiveStyles;
+}
+
+export interface ChildrenProps extends BaseProps {
+  children?: ReactNode | ReactNode[];
+  child?: ReactNode;
+}
+
+export type Alignment = 'start' | 'center' | 'end' | 'stretch';
+export type MainAxisAlignment = 'start' | 'center' | 'end' | 'spaceBetween' | 'spaceAround' | 'spaceEvenly';
+export type CrossAxisAlignment = Alignment;
+
+export interface LayoutProps extends BaseProps {
+  width?: string | number;
+  height?: string | number;
+  padding?: string | number;
+  margin?: string | number;
+  backgroundColor?: string;
+}
+
+export interface EdgeInsets {
+  top?: string | number;
+  right?: string | number;
+  bottom?: string | number;
+  left?: string | number;
+  all?: string | number;
+  horizontal?: string | number;
+  vertical?: string | number;
+}
+
+export interface TextStyle {
+  fontSize?: string | number;
+  fontWeight?: string | number;
+  fontFamily?: string;
+  color?: string;
+  lineHeight?: string | number;
+  letterSpacing?: string | number;
+}
+
+export type TextType = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'caption' | 'label';
+
+export type ButtonVariant = 'elevated' | 'filled' | 'outlined' | 'text';
+
+export type StatusType = 'success' | 'warning' | 'error' | 'info';
+
+export interface FiboComponent<T = any> {
+  (props?: T): ReactElement;
+}