archetype-ecs 1.0.0 → 1.2.0

package/src/Container.js

@@ -1,23 +0,0 @@
-export function createContainer() {
-  const factories = new Map();
-  const instances = new Map();
-
-  return {
-    register(key, factory) {
-      factories.set(key, factory);
-    },
-
-    resolve(key) {
-      if (instances.has(key)) {
-        return instances.get(key);
-      }
-      const factory = factories.get(key);
-      if (!factory) {
-        throw new Error(`No factory registered for key: ${key}`);
-      }
-      const instance = factory(this);
-      instances.set(key, instance);
-      return instance;
-    }
-  };
-}

package/src/EventBus.js

@@ -1,29 +0,0 @@
-export function createEventBus() {
-  const listeners = new Map();
-
-  return {
-    on(event, callback) {
-      if (!listeners.has(event)) {
-        listeners.set(event, []);
-      }
-      listeners.get(event).push(callback);
-    },
-
-    off(event, callback) {
-      const cbs = listeners.get(event);
-      if (cbs) {
-        const idx = cbs.indexOf(callback);
-        if (idx !== -1) cbs.splice(idx, 1);
-      }
-    },
-
-    emit(event, data) {
-      const cbs = listeners.get(event);
-      if (cbs) {
-        for (const cb of cbs) {
-          cb(data);
-        }
-      }
-    }
-  };
-}

package/src/GameLoop.js

@@ -1,110 +0,0 @@
-import { profiler } from './Profiler.js';
-
-export function createGameLoop(systems, renderSteps, { tickRate = 20, maxFrameTime = 250 } = {}) {
-  let running = false;
-  let lastTime = 0;
-  let accumulator = 0;
-  let tickCount = 0;
-  let frameCount = 0;
-  let fpsTime = 0;
-  let fps = 0;
-  let tps = 0;
-  let fpsLimit = 0;
-  let lastRenderTime = 0;
-  let tickDuration = 1000 / tickRate;
-  let rafId = 0;
-
-  function loop(currentTime) {
-    if (!running) return;
-
-    const frameTime = Math.min(currentTime - lastTime, maxFrameTime);
-    lastTime = currentTime;
-    accumulator += frameTime;
-
-    // Fixed timestep simulation
-    while (accumulator >= tickDuration) {
-      if (profiler.enabled) {
-        const tickStart = performance.now();
-        for (const system of systems) {
-          if (system.update) {
-            const t0 = performance.now();
-            system.update(tickDuration);
-            profiler.end(system.name || 'unnamed', t0);
-          }
-        }
-        profiler.end('Tick Total', tickStart);
-      } else {
-        for (const system of systems) {
-          if (system.update) system.update(tickDuration);
-        }
-      }
-      accumulator -= tickDuration;
-      tickCount++;
-    }
-
-    const alpha = accumulator / tickDuration;
-
-    // Render (respecting fps cap)
-    const minRenderInterval = fpsLimit > 0 ? 1000 / fpsLimit : 0;
-    if (minRenderInterval === 0 || currentTime - lastRenderTime >= minRenderInterval) {
-      if (profiler.enabled) {
-        const renderStart = performance.now();
-        for (const step of renderSteps) {
-          const t0 = performance.now();
-          step.fn(alpha, frameTime);
-          profiler.end(step.name, t0);
-        }
-        profiler.end('Render Total', renderStart);
-      } else {
-        for (const step of renderSteps) {
-          step.fn(alpha, frameTime);
-        }
-      }
-      lastRenderTime = currentTime;
-      frameCount++;
-    }
-
-    fpsTime += frameTime;
-    if (fpsTime >= 1000) {
-      fps = frameCount;
-      tps = tickCount;
-      frameCount = 0;
-      tickCount = 0;
-      fpsTime -= 1000;
-    }
-
-    rafId = requestAnimationFrame(loop);
-  }
-
-  return {
-    start() {
-      if (running) return;
-      running = true;
-      lastTime = performance.now();
-      lastRenderTime = 0;
-      rafId = requestAnimationFrame(loop);
-    },
-
-    stop() {
-      running = false;
-      cancelAnimationFrame(rafId);
-    },
-
-    setFpsLimit(limit) {
-      fpsLimit = limit;
-    },
-
-    setTickRate(rate) {
-      tickDuration = 1000 / rate;
-      accumulator = 0;
-    },
-
-    setProfilingEnabled(enabled) {
-      profiler.setEnabled(enabled);
-    },
-
-    getProfileData() { return profiler.getData(); },
-    getFps() { return fps; },
-    getTps() { return tps; }
-  };
-}

package/tests/Container.test.js

@@ -1,38 +0,0 @@
-import { describe, test, expect } from '@jest/globals';
-import { createContainer } from '../src/Container.js';
-
-describe('Container', () => {
-  test('register and resolve returns factory result', () => {
-    const container = createContainer();
-    container.register('greeting', () => 'hello');
-    expect(container.resolve('greeting')).toBe('hello');
-  });
-
-  test('singleton caching — resolves same instance', () => {
-    const container = createContainer();
-    let callCount = 0;
-    container.register('service', () => {
-      callCount++;
-      return { id: callCount };
-    });
-    const a = container.resolve('service');
-    const b = container.resolve('service');
-    expect(a).toBe(b);
-    expect(callCount).toBe(1);
-  });
-
-  test('factory receives container for dependency injection', () => {
-    const container = createContainer();
-    container.register('config', () => ({ port: 3000 }));
-    container.register('server', (c) => {
-      const config = c.resolve('config');
-      return { port: config.port };
-    });
-    expect(container.resolve('server')).toEqual({ port: 3000 });
-  });
-
-  test('throws for unregistered key', () => {
-    const container = createContainer();
-    expect(() => container.resolve('missing')).toThrow('No factory registered for key: missing');
-  });
-});

package/tests/EventBus.test.js

@@ -1,41 +0,0 @@
-import { describe, test, expect } from '@jest/globals';
-import { createEventBus } from '../src/EventBus.js';
-
-describe('EventBus', () => {
-  test('on/emit calls listener with data', () => {
-    const bus = createEventBus();
-    const received = [];
-    bus.on('test', (data) => received.push(data));
-    bus.emit('test', { value: 42 });
-    expect(received).toEqual([{ value: 42 }]);
-  });
-
-  test('multiple listeners on same event', () => {
-    const bus = createEventBus();
-    const results = [];
-    bus.on('test', () => results.push('a'));
-    bus.on('test', () => results.push('b'));
-    bus.emit('test');
-    expect(results).toEqual(['a', 'b']);
-  });
-
-  test('off removes listener', () => {
-    const bus = createEventBus();
-    const results = [];
-    const cb = () => results.push('called');
-    bus.on('test', cb);
-    bus.off('test', cb);
-    bus.emit('test');
-    expect(results).toEqual([]);
-  });
-
-  test('emit on non-existent event is a no-op', () => {
-    const bus = createEventBus();
-    expect(() => bus.emit('nonexistent', {})).not.toThrow();
-  });
-
-  test('off on non-existent event is a no-op', () => {
-    const bus = createEventBus();
-    expect(() => bus.off('nonexistent', () => {})).not.toThrow();
-  });
-});