@forgecharts/sdk 1.1.23

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@forgecharts/sdk",
+  "version": "1.1.23",
+  "description": "ForgeCharts SDK — canvas-based charting engine, no third-party chart libraries",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/forgecharts/ForgeCharts.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js",
+      "require": "./dist/internal.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup --no-dts && tsc --build --force tsconfig.json",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rimraf dist tsconfig.tsbuildinfo"
+  },
+  "dependencies": {
+    "@forgecharts/shared": "*",
+    "@forgecharts/types": "*",
+    "@forgecharts/utils": "*",
+    "pixi.js": "^8.16.0"
+  },
+  "devDependencies": {
+    "rimraf": "^5.0.10",
+    "tsup": "^8.2.4",
+    "typescript": "*",
+    "vitest": "^2.0.5"
+  }
+}

package/src/__tests__/backwardCompatibility.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Backward compatibility — unit tests
+ *
+ * Verifies that the introduction of licensing, unmanaged mode, and managed
+ * foundations does NOT break the existing SDK contract:
+ *
+ *   1. All expected exports exist and have the correct shape/type
+ *   2. CandleEngine works unchanged (no side-effects from new code)
+ *   3. Default mode is unmanaged (safe default — nothing breaks by default)
+ *   4. The RapidAPI datafeed path is unaffected (DatafeedConnector still exports)
+ *   5. New modules export correctly from the package root (index.ts)
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LicenseManager } from '../licensing/LicenseManager';
+import { CandleEngine } from '../engine/CandleEngine';
+import type { RawOHLCV } from '../engine/CandleEngine';
+
+// ─── License cleanup ──────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  LicenseManager.getInstance().clear();
+});
+
+// ─── Existing exports remain intact ──────────────────────────────────────────
+
+describe('Backward compatibility — SDK exports', () => {
+  it('CandleEngine is exported', async () => {
+    const mod = await import('../engine/CandleEngine');
+    expect(mod.CandleEngine).toBeDefined();
+    expect(typeof mod.CandleEngine).toBe('function');
+  });
+
+  it('timeframeToMs and getBucketStart are exported', async () => {
+    const mod = await import('../engine/timeframeUtils');
+    expect(typeof mod.timeframeToMs).toBe('function');
+    expect(typeof mod.getBucketStart).toBe('function');
+  });
+
+  it('LicenseManager is exported', async () => {
+    const mod = await import('../licensing/LicenseManager');
+    expect(mod.LicenseManager).toBeDefined();
+  });
+
+  it('ChartRuntimeResolver is exported', async () => {
+    const mod = await import('../licensing/ChartRuntimeResolver');
+    expect(mod.ChartRuntimeResolver).toBeDefined();
+    expect(typeof mod.isManagedMode).toBe('function');
+    expect(typeof mod.isUnmanagedMode).toBe('function');
+    expect(typeof mod.canRenderOrderEntry).toBe('function');
+    expect(typeof mod.canRenderManagedTradingControls).toBe('function');
+    expect(typeof mod.canRenderExternalOverlayOnlyMode).toBe('function');
+  });
+
+  it('TradingOverlayStore is exported', async () => {
+    const mod = await import('../trading/TradingOverlayStore');
+    expect(mod.TradingOverlayStore).toBeDefined();
+    expect(typeof mod.TradingOverlayStore).toBe('function');
+  });
+
+  it('UnmanagedIngestion is exported', async () => {
+    const mod = await import('../trading/UnmanagedIngestion');
+    expect(mod.UnmanagedIngestion).toBeDefined();
+    expect(typeof mod.UnmanagedIngestion).toBe('function');
+  });
+
+  it('ManagedTradingController is exported', async () => {
+    const mod = await import('../trading/managed/ManagedTradingController');
+    expect(mod.ManagedTradingController).toBeDefined();
+    expect(typeof mod.ManagedTradingController).toBe('function');
+  });
+
+  it('DatafeedConnector is exported (default RapidAPI path intact)', async () => {
+    const mod = await import('../datafeed/DatafeedConnector');
+    expect(mod.DatafeedConnector).toBeDefined();
+    expect(typeof mod.DatafeedConnector).toBe('function');
+  });
+});
+
+// ─── CandleEngine unchanged ───────────────────────────────────────────────────
+
+describe('Backward compatibility — CandleEngine still works with no license', () => {
+  // T0 = 2024-07-03T10:00:00Z in seconds
+  const T0 = 1_719_997_200;
+  const T1 = T0 + 60;
+
+  function raw(time: number, close: number): RawOHLCV {
+    return { time, open: 100, high: close + 5, low: close - 5, close, volume: 1 };
+  }
+
+  it('can be instantiated and used without any license', () => {
+    const engine = new CandleEngine();
+    expect(() => engine.initialize([], '1m')).not.toThrow();
+  });
+
+  it('basic OHLCV update works — no licensing side-effects', () => {
+    const engine = new CandleEngine();
+    engine.initialize([], '1m');
+
+    engine.applyLiveUpdate(raw(T0, 100));
+    engine.applyLiveUpdate(raw(T0, 105));
+    engine.applyLiveUpdate(raw(T1, 110));
+
+    expect(engine.getBars()).toHaveLength(2);
+    expect(engine.getBars()[0]!.close).toBe(105);
+    expect(engine.getBars()[1]!.close).toBe(110);
+  });
+
+  it('initialize() resets state completely', () => {
+    const engine = new CandleEngine();
+    engine.initialize([], '1m');
+    engine.applyLiveUpdate(raw(T0, 100));
+    engine.initialize([], '5m');
+    expect(engine.getBars()).toHaveLength(0);
+  });
+});
+
+// ─── Default license mode — safe unmanaged defaults ──────────────────────────
+
+describe('Backward compatibility — default mode is unmanaged', () => {
+  it('LicenseManager.getMode() returns unmanaged with no license', () => {
+    const lm = LicenseManager.getInstance();
+    expect(lm.getMode()).toBe('unmanaged');
+    expect(lm.getLicense()).toBeNull();
+  });
+
+  it('isUnmanagedMode() is true with no license', async () => {
+    const { isUnmanagedMode } = await import('../licensing/ChartRuntimeResolver');
+    expect(isUnmanagedMode()).toBe(true);
+  });
+
+  it('isManagedMode() is false with no license', async () => {
+    const { isManagedMode } = await import('../licensing/ChartRuntimeResolver');
+    expect(isManagedMode()).toBe(false);
+  });
+
+  it('canRenderCandles() is true with no license', async () => {
+    const { canRenderCandles } = await import('../licensing/ChartRuntimeResolver');
+    expect(canRenderCandles()).toBe(true);
+  });
+
+  it('canRenderorderEntry() is false with no license', async () => {
+    const { canRenderOrderEntry } = await import('../licensing/ChartRuntimeResolver');
+    expect(canRenderOrderEntry()).toBe(false);
+  });
+
+  it('canRenderManagedTradingControls() is false with no license', async () => {
+    const { canRenderManagedTradingControls } = await import('../licensing/ChartRuntimeResolver');
+    expect(canRenderManagedTradingControls()).toBe(false);
+  });
+});
+
+// ─── Unmanaged ingestion is additive — does not replace the existing datafeed ─
+
+describe('Backward compatibility — unmanaged ingestion is opt-in and additive', () => {
+  it('UnmanagedIngestion can be instantiated without affecting CandleEngine state', async () => {
+    const standaloneEngine = new CandleEngine();
+    standaloneEngine.initialize([], '1m');
+
+    // Creating an UnmanagedIngestion constructs its OWN internal CandleEngine
+    const { UnmanagedIngestion } = await import('../trading/UnmanagedIngestion');
+    const ing = new UnmanagedIngestion('1m');
+
+    // The standalone engine is still clean
+    expect(standaloneEngine.getBars()).toHaveLength(0);
+    // The ingestion engine also starts empty
+    expect(ing.getBars()).toHaveLength(0);
+  });
+
+  it('DatafeedConnector can still be constructed independently', async () => {
+    const { DatafeedConnector } = await import('../datafeed/DatafeedConnector');
+    const mockDatafeed = {
+      getHistoricalBars: () => Promise.resolve({ bars: [], noData: true }),
+      subscribeBars:     () => {},
+      unsubscribeBars:   () => {},
+    };
+    const mockSeries = {
+      setData:      () => {},
+      update:       () => {},
+      data:         () => [],
+      applyOptions: () => {},
+      options:      () => ({} as never),
+    };
+    const mockCallbacks = {
+      onLoading: () => {},
+      onLoaded:  () => {},
+      onError:   () => {},
+    };
+    expect(() => new DatafeedConnector(mockDatafeed, mockSeries, mockCallbacks)).not.toThrow();
+  });
+});