@chatbi-v/mocks 1.0.1

package/dist/interceptor.d.ts

@@ -0,0 +1,10 @@
+import { MockSchema } from './types';
+declare global {
+    interface Window {
+        _originalFetch: typeof fetch;
+        _originalEventSource: typeof EventSource;
+    }
+}
+export declare function installFetchMock(schema: MockSchema): void;
+export declare function installSSEMock(): void;
+export declare function setupMock(schema: MockSchema): void;

package/dist/interceptor.js

@@ -0,0 +1,67 @@
+import { StrategyFactory } from './strategies';
+import { eventsToStream, sleep } from './utils';
+export function installFetchMock(schema) {
+    if (!window._originalFetch) {
+        window._originalFetch = window.fetch;
+    }
+    window.fetch = async (input, init = {}) => {
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+        const method = (init.method || 'GET').toUpperCase();
+        // Find matching rule
+        const rules = Object.values(schema);
+        const rule = rules.find((v) => {
+            if (!v.url)
+                return false;
+            // Convert route params :id to regex \w+
+            // We might want to be more specific, e.g., ([^/]+)
+            const pattern = v.url.replace(/:[a-zA-Z0-9_]+/g, '([^/]+)');
+            const regex = new RegExp(`^${pattern}$`);
+            // Check if URL matches (ignoring query params for the match, but we might need them later)
+            const [path] = url.split('?');
+            // Match method if specified, default to GET match? or just match URL?
+            // Usually method matters.
+            const ruleMethod = (v.method || 'GET').toUpperCase();
+            return regex.test(path) && ruleMethod === method;
+        });
+        if (!rule) {
+            return window._originalFetch(input, init);
+        }
+        console.log(`[Mock] Intercepted ${method} ${url}`, rule);
+        await sleep(rule.delay || 0);
+        // Determine type (default 'json' if not present)
+        const type = rule.type || 'json';
+        const strategy = StrategyFactory.getStrategy(type);
+        // Parse query params for strategies that need them
+        const urlObj = new URL(url, window.location.origin);
+        const query = Object.fromEntries(urlObj.searchParams);
+        const result = strategy.process(rule, query);
+        /* 1. JSON Response */
+        if (type === 'json') {
+            return new Response(JSON.stringify(result), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        /* 2. SSE / SSE-Page Response */
+        if (type === 'sse' || type === 'sse-page') {
+            const events = result; // Strategy returns MockEvent[]
+            const stream = eventsToStream(events);
+            return new Response(stream, {
+                status: 200,
+                headers: { 'Content-Type': 'text/event-stream' }
+            });
+        }
+        return window._originalFetch(input, init);
+    };
+}
+export function installSSEMock() {
+    // Placeholder for EventSource mocking if needed.
+    // Currently, we rely on fetch interception.
+    // Many modern apps use fetch for SSE (POST requests, headers, etc.)
+}
+export function setupMock(schema) {
+    if (typeof window !== 'undefined') {
+        installFetchMock(schema);
+        installSSEMock();
+    }
+}

package/dist/strategies.d.ts

@@ -0,0 +1,20 @@
+import { MockConfig, MockEvent, MockGeneratorStrategy, // Legacy
+MockStrategy } from './types';
+export declare class ChatStreamStrategy implements MockGeneratorStrategy {
+    generate(schema: any): string[];
+}
+export declare class HistoryStreamStrategy implements MockGeneratorStrategy {
+    generate(schema: any): string[];
+}
+export declare class JsonStrategy implements MockStrategy {
+    process(config: MockConfig, _requestParams?: any): any;
+}
+export declare class SseStrategy implements MockStrategy {
+    process(config: MockConfig, requestParams?: any): MockEvent[];
+}
+export declare class SsePageStrategy implements MockStrategy {
+    process(config: MockConfig, requestParams?: any): MockEvent[];
+}
+export declare const StrategyFactory: {
+    getStrategy(type?: string): MockStrategy;
+};

package/dist/strategies.js

@@ -0,0 +1,127 @@
+import Mock from 'mockjs';
+import { MockResponseGenerator } from './generator';
+import { flatEvents, processTemplate } from './utils';
+// === Legacy Strategies (Preserved) ===
+export class ChatStreamStrategy {
+    generate(schema) {
+        const config = schema;
+        const defaultName = config.agentName || 'BI助手';
+        const generator = new MockResponseGenerator(defaultName);
+        const mockData = config.data ? Mock.mock(config.data) : {};
+        // 1. Init Plan
+        if (config.plan) {
+            generator.initPlan(config.plan);
+        }
+        // 2. Execute Timeline
+        if (config.timeline) {
+            config.timeline.forEach(step => {
+                if (step.planIndex !== undefined) {
+                    generator.updatePlanStatus(step.planIndex);
+                }
+                if (step.log) {
+                    const logContent = typeof step.log === 'string' ? step.log : step.log.content;
+                    const logLevel = typeof step.log === 'object' ? step.log.level : 'info';
+                    const logAgent = typeof step.log === 'object' ? step.log.agent : undefined;
+                    generator.addLog(logContent, logLevel, logAgent);
+                }
+            });
+        }
+        // 3. Content
+        let content;
+        if (typeof config.content === 'function') {
+            content = config.content(mockData);
+        }
+        else {
+            content = config.content;
+        }
+        if (typeof content === 'object' && content !== null) {
+            generator.emitA2UI(content);
+        }
+        else {
+            generator.streamContent(content);
+        }
+        // 4. Complete
+        generator.completePlan();
+        generator.finish();
+        return generator.toString().split('\n\n').map(chunk => chunk + '\n\n');
+    }
+}
+export class HistoryStreamStrategy {
+    generate(schema) {
+        const config = schema;
+        const generator = new MockResponseGenerator('BI助手');
+        const historyMock = Mock.mock(config.template);
+        const fullHistory = [...(config.prepend || []), ...(historyMock.list || historyMock)];
+        generator.emitHistory(fullHistory);
+        return generator.toString().split('\n\n').map(chunk => chunk + '\n\n');
+    }
+}
+// === New Schema Strategies ===
+export class JsonStrategy {
+    process(config, _requestParams) {
+        const jsonConfig = config;
+        if (!jsonConfig.responseSchema)
+            return {};
+        return Mock.mock(jsonConfig.responseSchema);
+    }
+}
+export class SseStrategy {
+    process(config, requestParams = {}) {
+        const sseConfig = config;
+        if (!sseConfig.responseSchema)
+            return [];
+        // Use flatEvents to process the schema with MockJS and sort by delay
+        return flatEvents(sseConfig.responseSchema, requestParams);
+    }
+}
+export class SsePageStrategy {
+    process(config, requestParams = {}) {
+        const ssePageConfig = config;
+        if (!ssePageConfig.responseSchema)
+            return [];
+        // 1. Generate base events
+        const events = flatEvents(ssePageConfig.responseSchema, requestParams);
+        // 2. Generate page event if exists
+        if (ssePageConfig.pageEvent) {
+            Mock.Random.extend({ $query: () => requestParams });
+            // First let Mock.js process standard templates (like @integer)
+            let pageEvent = Mock.mock(ssePageConfig.pageEvent);
+            // Then process custom {{}} templates
+            pageEvent = processTemplate(pageEvent, { $query: requestParams });
+            // Calculate max delay from existing events to ensure page event is last
+            let maxDelay = 0;
+            if (events.length > 0) {
+                const lastEvent = events[events.length - 1];
+                maxDelay = typeof lastEvent.delay === 'number' ? lastEvent.delay : parseInt(String(lastEvent.delay || 0));
+            }
+            // Set page event delay to be slightly after the last event
+            const pageDelay = typeof pageEvent.delay === 'number' ? pageEvent.delay : parseInt(String(pageEvent.delay || 0));
+            if (pageDelay <= maxDelay) {
+                pageEvent.delay = maxDelay + 20; // Add small buffer
+            }
+            events.push(pageEvent);
+        }
+        // Re-sort in case pageEvent has specific delay
+        const es = events.sort((a, b) => {
+            const delayA = typeof a.delay === 'number' ? a.delay : parseInt(String(a.delay || 0));
+            const delayB = typeof b.delay === 'number' ? b.delay : parseInt(String(b.delay || 0));
+            return delayA - delayB;
+        });
+        console.log(es);
+        return es;
+    }
+}
+// Factory for new strategies
+export const StrategyFactory = {
+    getStrategy(type = 'json') {
+        switch (type) {
+            case 'sse':
+                return new SseStrategy();
+            case 'sse-page':
+                return new SsePageStrategy();
+            case 'json':
+            default:
+                return new JsonStrategy();
+        }
+    }
+};

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+export type MockMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type MockType = 'json' | 'sse' | 'sse-page';
+export interface MockEvent {
+    event: string;
+    data: any;
+    /** Delay in ms, or a mockjs template string like '@increment(100)' */
+    delay?: number | string;
+}
+export interface MockStrategy {
+    /**
+     * Process the schema and return the result.
+     * For JSON: returns the mocked object.
+     * For SSE: returns an array of formatted event strings (chunks).
+     */
+    process(config: MockConfig, requestParams?: any): any;
+}
+export interface BaseMockConfig {
+    /** Optional: URL pattern if used in global interceptor */
+    url?: string;
+    /** Optional: Method if used in global interceptor */
+    method?: MockMethod;
+    /** Global delay for the request */
+    delay?: number;
+    /** Mock type (default: 'json') */
+    type?: MockType;
+}
+export interface JsonMockConfig extends BaseMockConfig {
+    type?: 'json';
+    /** The MockJS template for the response body */
+    responseSchema: any;
+}
+export interface SseMockConfig extends BaseMockConfig {
+    type: 'sse';
+    /**
+     * Dictionary of event templates.
+     * Key can be a mockjs template like 'data|3-5'
+     */
+    responseSchema: Record<string, MockEvent[]>;
+}
+export interface SsePageMockConfig extends BaseMockConfig {
+    type: 'sse-page';
+    /** Dictionary of event templates */
+    responseSchema: Record<string, MockEvent[]>;
+    /** Special event for pagination metadata */
+    pageEvent: MockEvent;
+}
+export type MockConfig = JsonMockConfig | SseMockConfig | SsePageMockConfig;
+export type MockSchema = Record<string, MockConfig>;
+export interface ChatStreamConfig {
+    _type: 'chat_stream';
+    agentName?: string;
+    plan?: string[];
+    data?: Record<string, any>;
+    timeline?: Array<{
+        log?: string | {
+            content: string;
+            level?: 'info' | 'warning' | 'error';
+            agent?: string;
+        };
+        planIndex?: number;
+        delay?: number;
+    }>;
+    content: string | Record<string, any> | ((data: any) => string | Record<string, any>);
+}
+export interface HistoryStreamConfig {
+    _type: 'history_stream';
+    template: Record<string, any>;
+    prepend?: any[];
+}
+export type AdvancedMockSchema = ChatStreamConfig | HistoryStreamConfig;
+export interface MockGeneratorStrategy {
+    generate(schema: any): string[];
+}
+export declare function createChatStream(config: Omit<ChatStreamConfig, '_type'>): ChatStreamConfig;
+export declare function createHistoryStream(config: Omit<HistoryStreamConfig, '_type'>): HistoryStreamConfig;

package/dist/types.js

@@ -0,0 +1,7 @@
+// === Helper Functions (Restored) ===
+export function createChatStream(config) {
+    return { _type: 'chat_stream', ...config };
+}
+export function createHistoryStream(config) {
+    return { _type: 'history_stream', ...config };
+}

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+import { MockEvent } from './types';
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * Process string templates like "{{$query.pageNo * 10}}" in object values.
+ * Uses simple evaluation with limited context.
+ */
+export declare function processTemplate(data: any, context: Record<string, any>): any;
+/**
+ * Flatten eventsSchema into a sorted array of events.
+ * It also extends Mock.Random with $query to access URL parameters.
+ *
+ * Supports Mock.js array generation rules in keys, e.g.:
+ * { 'data|8-12': [{ event: 'data', ... }] }
+ * -> generates 8 to 12 data events.
+ */
+export declare function flatEvents(eventsSchema: Record<string, MockEvent[]>, query?: Record<string, string>): MockEvent[];
+/**
+ * Convert an array of events into a ReadableStream (for SSE).
+ */
+export declare function eventsToStream(events: MockEvent[]): ReadableStream;

package/dist/utils.js

@@ -0,0 +1,103 @@
+import dayjs from 'dayjs';
+import Mock from 'mockjs';
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Process string templates like "{{$query.pageNo * 10}}" in object values.
+ * Uses simple evaluation with limited context.
+ */
+export function processTemplate(data, context) {
+    if (typeof data === 'string') {
+        // Check for {{ ... }} pattern
+        if (/^\{\{.*\}\}$/.test(data)) {
+            const expression = data.slice(2, -2).trim();
+            try {
+                // Safe evaluation using Function with context keys
+                const keys = Object.keys(context);
+                const values = Object.values(context);
+                const fn = new Function(...keys, `return ${expression}`);
+                return fn(...values);
+            }
+            catch (e) {
+                console.warn(`[Mock] Failed to evaluate template: ${data}`, e);
+                return data;
+            }
+        }
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(item => processTemplate(item, context));
+    }
+    if (typeof data === 'object' && data !== null) {
+        const result = {};
+        for (const key in data) {
+            result[key] = processTemplate(data[key], context);
+        }
+        return result;
+    }
+    return data;
+}
+/**
+ * Flatten eventsSchema into a sorted array of events.
+ * It also extends Mock.Random with $query to access URL parameters.
+ *
+ * Supports Mock.js array generation rules in keys, e.g.:
+ * { 'data|8-12': [{ event: 'data', ... }] }
+ * -> generates 8 to 12 data events.
+ */
+export function flatEvents(eventsSchema, query = {}) {
+    // Extend Mock.Random to support $query
+    Mock.Random.extend({
+        $query: function () {
+            return query;
+        }
+    });
+    // Generate data using Mock.mock
+    // This handles keys like 'data|8-12' to generate arrays
+    const compiled = Mock.mock(eventsSchema);
+    // Flatten and sort by delay
+    return Object.values(compiled)
+        .flat()
+        .map(event => processTemplate(event, { $query: query })) // Apply template replacement
+        .sort((a, b) => {
+        const delayA = typeof a.delay === 'number' ? a.delay : parseInt(String(a.delay || 0));
+        const delayB = typeof b.delay === 'number' ? b.delay : parseInt(String(b.delay || 0));
+        return delayA - delayB;
+    });
+}
+/**
+ * Convert an array of events into a ReadableStream (for SSE).
+ */
+export function eventsToStream(events) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        start(ctrl) {
+            // Check if events is empty
+            if (!events || events.length === 0) {
+                ctrl.close();
+                return;
+            }
+            (async () => {
+                try {
+                    // We assume events are sorted by their `delay` property which represents 
+                    // "absolute time from start".
+                    const startTime = dayjs().valueOf();
+                    for (const eventItem of events) {
+                        const delay = typeof eventItem.delay === 'number' ? eventItem.delay : parseInt(String(eventItem.delay || 0));
+                        // Calculate how much time passed since start
+                        const elapsed = dayjs().valueOf() - startTime;
+                        const remaining = Math.max(0, delay - elapsed);
+                        if (remaining > 0) {
+                            await sleep(remaining);
+                        }
+                        const payload = `event: ${eventItem.event}\ndata: ${JSON.stringify(eventItem.data)}\n\n`;
+                        ctrl.enqueue(encoder.encode(payload));
+                    }
+                    ctrl.close();
+                }
+                catch (e) {
+                    ctrl.error(e);
+                }
+            })();
+        },
+    });
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@chatbi-v/mocks",
+  "version": "1.0.1",
+  "main": "dist/index.cjs",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "mockjs": "^1.1.0",
+    "@chatbi-v/core": "1.0.2"
+  },
+  "peerDependencies": {
+    "@chatbi-v/cli": "1.0.2"
+  },
+  "devDependencies": {
+    "@types/mockjs": "^1.0.10",
+    "tsup": "^8.5.1",
+    "@chatbi-v/tsconfig": "1.0.2"
+  },
+  "scripts": {
+    "build": "chatbi-cli build",
+    "dev": "chatbi-cli build --watch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}