zylaris 1.0.2

package/packages/reactivity/src/signal.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi } from 'vitest';
+import { signal, createEffect, batch } from './signal.js';
+
+describe('signal', () => {
+  it('should create a signal with initial value', () => {
+    const s = signal(10);
+    expect(s()).toBe(10);
+  });
+
+  it('should update signal value', () => {
+    const s = signal(10);
+    s.set(20);
+    expect(s()).toBe(20);
+  });
+
+  it('should update signal with function', () => {
+    const s = signal(10);
+    s.update(v => v * 2);
+    expect(s()).toBe(20);
+  });
+
+  it('should peek value without tracking', () => {
+    const s = signal(10);
+    expect(s.peek()).toBe(10);
+  });
+
+  it('should subscribe to changes', () => {
+    const s = signal(10);
+    const fn = vi.fn();
+    const unsubscribe = s.subscribe(fn);
+    
+    s.set(20);
+    // Wait for microtask
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(fn).toHaveBeenCalledWith(20);
+        unsubscribe();
+        resolve(undefined);
+      }, 10);
+    });
+  });
+
+  it('should not update if value is the same', async () => {
+    const s = signal(10);
+    const fn = vi.fn();
+    s.subscribe(fn);
+    
+    // Wait for initial call
+    await new Promise(resolve => setTimeout(resolve, 10));
+    expect(fn).toHaveBeenCalledTimes(1); // Initial call
+    expect(fn).toHaveBeenCalledWith(10);
+    
+    fn.mockClear();
+    s.set(10); // Same value
+    
+    await new Promise(resolve => setTimeout(resolve, 10));
+    expect(fn).not.toHaveBeenCalled(); // No additional call
+  });
+});
+
+describe('createEffect', () => {
+  it('should run effect immediately', () => {
+    const fn = vi.fn();
+    createEffect(fn);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should track signal dependencies', () => {
+    const s = signal(10);
+    const fn = vi.fn();
+    
+    createEffect(() => {
+      fn(s());
+    });
+    
+    s.set(20);
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(fn).toHaveBeenCalledWith(20);
+        expect(fn).toHaveBeenCalledTimes(2);
+        resolve(undefined);
+      }, 10);
+    });
+  });
+
+  it('should cleanup on dispose', () => {
+    const s = signal(10);
+    const fn = vi.fn();
+    
+    const dispose = createEffect(() => {
+      fn(s());
+    });
+    
+    dispose();
+    s.set(20);
+    
+    return new Promise(resolve => {
+      setTimeout(() => {
+        expect(fn).toHaveBeenCalledTimes(1); // Should not run again
+        resolve(undefined);
+      }, 10);
+    });
+  });
+});
+
+describe('batch', () => {
+  it('should batch updates', () => {
+    const s1 = signal(10);
+    const s2 = signal(20);
+    const fn = vi.fn();
+    
+    createEffect(() => {
+      fn(s1(), s2());
+    });
+    
+    batch(() => {
+      s1.set(100);
+      s2.set(200);
+    });
+    
+    return new Promise(resolve => {
+      setTimeout(() => {
+        // Effect should only run twice: initial + after batch
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(fn).toHaveBeenLastCalledWith(100, 200);
+        resolve(undefined);
+      }, 10);
+    });
+  });
+});

package/packages/reactivity/src/signal.ts

@@ -0,0 +1,207 @@
+import type { Signal, SignalNode, Effect, EffectFn } from './types.js';
+import { getCurrentComputed } from './computed.js';
+
+// Global context for tracking dependencies
+let currentObserver: Effect | null = null;
+const effectStack: Effect[] = [];
+
+// Effect scheduling queue
+const effectQueue: Effect[] = [];
+let isFlushing = false;
+
+// Track if we're in batch mode
+let batchDepth = 0;
+const pendingEffects = new Set<Effect>();
+
+export function signal<T>(initialValue: T): Signal<T> {
+  const node: SignalNode<T> = {
+    value: initialValue,
+    observers: new Set(),
+    version: 0,
+  };
+
+  function read(): T {
+    // Track dependency if inside an effect
+    if (currentObserver) {
+      node.observers.add(currentObserver);
+      currentObserver.sources = currentObserver.sources || new Set();
+      currentObserver.sources.add(node as SignalNode<unknown>);
+    }
+    
+    // Track dependency if inside computed
+    const computed = getCurrentComputed();
+    if (computed) {
+      computed.deps.add(node as SignalNode<unknown>);
+    }
+    
+    return node.value;
+  }
+
+  function set(value: T): void {
+    if (Object.is(node.value, value)) return;
+    node.value = value;
+    node.version++;
+    notifyObservers(node);
+  }
+
+  function update(fn: (value: T) => T): void {
+    set(fn(node.value));
+  }
+
+  function peek(): T {
+    return node.value;
+  }
+
+  function subscribe(fn: (value: T) => void): () => void {
+    return createEffect(() => fn(read()));
+  }
+
+  return Object.assign(read, { set, update, peek, subscribe });
+}
+
+function notifyObservers<T>(node: SignalNode<T>): void {
+  const observers = Array.from(node.observers);
+  for (const effect of observers) {
+    if (batchDepth > 0) {
+      pendingEffects.add(effect);
+    } else {
+      scheduleEffect(effect);
+    }
+  }
+}
+
+export function createEffect(fn: EffectFn): () => void {
+  const effect: Effect = {
+    fn,
+    dependencies: new Set(),
+    version: 0,
+    scheduled: false,
+    sources: new Set(),
+  };
+
+  // Initial run
+  runEffect(effect);
+
+  return () => disposeEffect(effect);
+}
+
+function runEffect(effect: Effect): void {
+  // Cleanup previous dependencies
+  cleanupEffect(effect);
+
+  // Push to stack
+  effectStack.push(effect);
+  const prevObserver = currentObserver;
+  currentObserver = effect;
+
+  try {
+    const cleanup = effect.fn();
+    if (typeof cleanup === 'function') {
+      effect.cleanup = cleanup;
+    }
+  } finally {
+    // Pop from stack
+    effectStack.pop();
+    currentObserver = prevObserver;
+  }
+}
+
+function cleanupEffect(effect: Effect): void {
+  // Remove this effect from all signal observers
+  if (effect.sources) {
+    for (const source of effect.sources) {
+      source.observers.delete(effect);
+    }
+    effect.sources.clear();
+  }
+  effect.dependencies.clear();
+
+  // Run cleanup function if exists
+  if (effect.cleanup) {
+    effect.cleanup();
+    effect.cleanup = undefined;
+  }
+}
+
+function disposeEffect(effect: Effect): void {
+  cleanupEffect(effect);
+  // Remove from queue if scheduled
+  const index = effectQueue.indexOf(effect);
+  if (index !== -1) {
+    effectQueue.splice(index, 1);
+  }
+  pendingEffects.delete(effect);
+}
+
+function scheduleEffect(effect: Effect): void {
+  if (effect.scheduled) return;
+  effect.scheduled = true;
+  effectQueue.push(effect);
+
+  if (!isFlushing && batchDepth === 0) {
+    isFlushing = true;
+    queueMicrotask(flushEffects);
+  }
+}
+
+function flushEffects(): void {
+  isFlushing = true;
+
+  while (effectQueue.length > 0) {
+    const effect = effectQueue.shift()!;
+    effect.scheduled = false;
+    runEffect(effect);
+  }
+
+  isFlushing = false;
+}
+
+// Export for testing - force synchronous flush
+export function flushSync(): void {
+  flushEffects();
+}
+
+export function batch<T>(fn: () => T): T {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      // Flush all pending effects
+      const effects = Array.from(pendingEffects);
+      pendingEffects.clear();
+      for (const effect of effects) {
+        scheduleEffect(effect);
+      }
+      if (!isFlushing && effectQueue.length > 0) {
+        isFlushing = true;
+        queueMicrotask(flushEffects);
+      }
+    }
+  }
+}
+
+// Lifecycle hooks
+export function onMount(fn: () => void | (() => void)): void {
+  if (typeof window !== 'undefined') {
+    createEffect(() => {
+      fn();
+      // Only run once
+      return () => {};
+    });
+  }
+}
+
+export function onCleanup(fn: () => void): void {
+  if (currentObserver) {
+    const prevCleanup = currentObserver.cleanup;
+    currentObserver.cleanup = () => {
+      prevCleanup?.();
+      fn();
+    };
+  }
+}
+
+// Export for computed.ts
+export { currentObserver };

package/packages/reactivity/src/store.d.ts

@@ -0,0 +1,4 @@
+import type { Store } from './types.js';
+export declare function createStore<T extends object>(initialValue: T): Store<T>;
+export declare function isStore(value: unknown): value is Store<object>;
+//# sourceMappingURL=store.d.ts.map

package/packages/reactivity/src/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKxC,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAwCvE;AA6BD,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC,CAI9D"}

package/packages/reactivity/src/store.js

@@ -0,0 +1,62 @@
+import { signal } from './signal.js';
+const STORE_SYMBOL = Symbol('zylaris-store');
+export function createStore(initialValue) {
+    const state = signal(initialValue);
+    const subscribers = new Map();
+    function notify(key) {
+        const subs = subscribers.get(key);
+        if (subs) {
+            for (const sub of subs) {
+                sub();
+            }
+        }
+    }
+    const proxy = new Proxy(initialValue, {
+        get(target, key) {
+            if (key === STORE_SYMBOL)
+                return true;
+            if (key === '$set')
+                return (value) => state.set(value);
+            const value = target[key];
+            // Return reactive wrapper for nested objects
+            if (typeof value === 'object' && value !== null) {
+                return createNestedProxy(value, () => notify(key));
+            }
+            return value;
+        },
+        set(target, key, value) {
+            const oldValue = target[key];
+            if (Object.is(oldValue, value))
+                return true;
+            target[key] = value;
+            notify(key);
+            return true;
+        },
+    });
+    return proxy;
+}
+function createNestedProxy(target, notify) {
+    return new Proxy(target, {
+        get(target, key) {
+            const value = target[key];
+            if (typeof value === 'object' && value !== null) {
+                return createNestedProxy(value, notify);
+            }
+            return value;
+        },
+        set(target, key, value) {
+            const oldValue = target[key];
+            if (Object.is(oldValue, value))
+                return true;
+            target[key] = value;
+            notify();
+            return true;
+        },
+    });
+}
+export function isStore(value) {
+    return typeof value === 'object' &&
+        value !== null &&
+        STORE_SYMBOL in value;
+}
+//# sourceMappingURL=store.js.map

package/packages/reactivity/src/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,YAAY,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AAE7C,MAAM,UAAU,WAAW,CAAmB,YAAe;IAC3D,MAAM,KAAK,GAAG,MAAM,CAAI,YAAY,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAoC,CAAC;IAEhE,SAAS,MAAM,CAAC,GAAoB;QAClC,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,GAAG,EAAE,CAAC;YACR,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,YAAY,EAAE;QACpC,GAAG,CAAC,MAAM,EAAE,GAAG;YACb,IAAI,GAAG,KAAK,YAAY;gBAAE,OAAO,IAAI,CAAC;YACtC,IAAI,GAAG,KAAK,MAAM;gBAAE,OAAO,CAAC,KAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAE1D,MAAM,KAAK,GAAG,MAAM,CAAC,GAAc,CAAC,CAAC;YAErC,6CAA6C;YAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAChD,OAAO,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACrD,CAAC;YAED,OAAO,KAAK,CAAC;QACf,CAAC;QACD,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK;YACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAc,CAAC,CAAC;YAExC,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAE5C,MAAM,CAAC,GAAc,CAAC,GAAG,KAAK,CAAC;YAC/B,MAAM,CAAC,GAAG,CAAC,CAAC;YAEZ,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAa,CAAC;IAEf,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,iBAAiB,CACxB,MAAS,EACT,MAAkB;IAElB,OAAO,IAAI,KAAK,CAAC,MAAM,EAAE;QACvB,GAAG,CAAC,MAAM,EAAE,GAAG;YACb,MAAM,KAAK,GAAG,MAAM,CAAC,GAAc,CAAC,CAAC;YAErC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAChD,OAAO,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC1C,CAAC;YAED,OAAO,KAAK,CAAC;QACf,CAAC;QACD,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK;YACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAc,CAAC,CAAC;YAExC,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAE5C,MAAM,CAAC,GAAc,CAAC,GAAG,KAAK,CAAC;YAC/B,MAAM,EAAE,CAAC;YAET,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,YAAY,IAAI,KAAK,CAAC;AAC/B,CAAC"}

package/packages/reactivity/src/store.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { createStore, isStore } from './store.js';
+
+describe('createStore', () => {
+  it('should create a store from object', () => {
+    const store = createStore({ count: 0, name: 'test' });
+    
+    expect(store.count).toBe(0);
+    expect(store.name).toBe('test');
+  });
+
+  it('should update store values', () => {
+    const store = createStore({ count: 0 });
+    store.count = 5;
+    
+    expect(store.count).toBe(5);
+  });
+
+  it('should handle nested objects', () => {
+    const store = createStore({ user: { name: 'John', age: 30 } });
+    
+    expect(store.user.name).toBe('John');
+    expect(store.user.age).toBe(30);
+  });
+});
+
+describe('isStore', () => {
+  it('should detect store correctly', () => {
+    const store = createStore({ count: 0 });
+    const plain = { count: 0 };
+    
+    expect(isStore(store)).toBe(true);
+    expect(isStore(plain)).toBe(false);
+    expect(isStore(null)).toBe(false);
+    expect(isStore(undefined)).toBe(false);
+    expect(isStore('string')).toBe(false);
+  });
+});

package/packages/reactivity/src/store.ts

@@ -0,0 +1,111 @@
+import type { Store } from './types.js';
+import { signal } from './signal.js';
+
+// Use a string key instead of Symbol for cross-realm compatibility
+const STORE_MARKER = '__zylaris_store__';
+
+export function createStore<T extends object>(initialValue: T): Store<T> {
+  const state = signal<T>(initialValue);
+  const subscribers = new Map<string | symbol, Set<() => void>>();
+
+  function notify(key: string | symbol) {
+    const subs = subscribers.get(key);
+    if (subs) {
+      for (const sub of subs) {
+        sub();
+      }
+    }
+  }
+
+  // Create store object with marker
+  const storeBase: Record<string, unknown> = { 
+    ...initialValue, 
+    [STORE_MARKER]: true 
+  };
+
+  const proxy = new Proxy(storeBase, {
+    get(target, key) {
+      if (key === STORE_MARKER) return true;
+      if (key === '$set') return (value: T) => state.set(value);
+      
+      const value = target[key as string];
+      
+      // Skip internal keys
+      if (key === Symbol.toStringTag || key === 'constructor') {
+        return value;
+      }
+      
+      // Return reactive wrapper for nested objects
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        return createNestedProxy(value as object, () => notify(key));
+      }
+      
+      return value;
+    },
+    set(target, key, value) {
+      const oldValue = target[key as string];
+      
+      if (Object.is(oldValue, value)) return true;
+      
+      target[key as string] = value;
+      notify(key);
+      
+      // Update underlying signal
+      state.set({ ...target } as T);
+      
+      return true;
+    },
+    has(target, key) {
+      return key in target || key === STORE_MARKER;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      if (key === STORE_MARKER) {
+        return {
+          value: true,
+          writable: false,
+          enumerable: false,
+          configurable: true,
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    },
+  }) as unknown as Store<T>;
+
+  return proxy;
+}
+
+function createNestedProxy<T extends object>(
+  target: T,
+  notify: () => void
+): T {
+  return new Proxy(target, {
+    get(target, key) {
+      const value = target[key as keyof T];
+      
+      if (typeof value === 'object' && value !== null) {
+        return createNestedProxy(value, notify);
+      }
+      
+      return value;
+    },
+    set(target, key, value) {
+      const oldValue = target[key as keyof T];
+      
+      if (Object.is(oldValue, value)) return true;
+      
+      target[key as keyof T] = value;
+      notify();
+      
+      return true;
+    },
+  });
+}
+
+export function isStore(value: unknown): value is Store<object> {
+  return typeof value === 'object' && 
+         value !== null && 
+         STORE_MARKER in value;
+}

package/packages/reactivity/src/types.d.ts

@@ -0,0 +1,43 @@
+export interface Signal<T> {
+    (): T;
+    set(value: T): void;
+    update(fn: (value: T) => T): void;
+    peek(): T;
+    subscribe(fn: (value: T) => void): () => void;
+}
+export interface Computed<T> extends Signal<T> {
+}
+export type ResourceState<T> = {
+    status: 'pending';
+    data?: undefined;
+    error?: undefined;
+} | {
+    status: 'success';
+    data: T;
+    error?: undefined;
+} | {
+    status: 'error';
+    data?: undefined;
+    error: Error;
+};
+export interface Resource<T> extends Signal<ResourceState<T>> {
+    refetch(): Promise<void>;
+    mutate(data: T): void;
+}
+export type EffectFn = () => void | (() => void);
+export interface Effect {
+    fn: EffectFn;
+    dependencies: Set<SignalNode<unknown>>;
+    version: number;
+    scheduled: boolean;
+    cleanup?: () => void;
+}
+export interface SignalNode<T> {
+    value: T;
+    observers: Set<Effect>;
+    version: number;
+}
+export type Store<T> = T & {
+    $set(value: T): void;
+};
+//# sourceMappingURL=types.d.ts.map

package/packages/reactivity/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,IAAI,CAAC,CAAC;IACN,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAClC,IAAI,IAAI,CAAC,CAAC;IACV,SAAS,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;CAAG;AAEjD,MAAM,MAAM,aAAa,CAAC,CAAC,IACvB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GAC1D;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GACjD;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAC3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;AAEjD,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,QAAQ,CAAC;IACb,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC;IACT,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAGD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG;IACzB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACtB,CAAC"}

package/packages/reactivity/src/types.js

@@ -0,0 +1,3 @@
+// Core types for the reactivity system
+export {};
+//# sourceMappingURL=types.js.map

package/packages/reactivity/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,uCAAuC"}

package/packages/reactivity/src/types.ts

@@ -0,0 +1,43 @@
+// Core types for the reactivity system
+
+export interface Signal<T> {
+  (): T;
+  set(value: T): void;
+  update(fn: (value: T) => T): void;
+  peek(): T;
+  subscribe(fn: (value: T) => void): () => void;
+}
+
+export interface Computed<T> extends Signal<T> {}
+
+export type ResourceState<T> =
+  | { status: 'pending'; data?: undefined; error?: undefined }
+  | { status: 'success'; data: T; error?: undefined }
+  | { status: 'error'; data?: undefined; error: Error };
+
+export interface Resource<T> extends Signal<ResourceState<T>> {
+  refetch(): Promise<void>;
+  mutate(data: T): void;
+}
+
+export type EffectFn = () => void | (() => void);
+
+export interface Effect {
+  fn: EffectFn;
+  dependencies: Set<SignalNode<unknown>>;
+  sources?: Set<SignalNode<unknown>>;
+  version: number;
+  scheduled: boolean;
+  cleanup?: () => void;
+}
+
+export interface SignalNode<T> {
+  value: T;
+  observers: Set<Effect>;
+  version: number;
+}
+
+// Store types
+export type Store<T> = T & {
+  $set(value: T): void;
+};

package/packages/reactivity/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts"]
+}