11.26 修改K线图样式

node_modules/@posthog/core/dist/testing/PostHogCoreTestClient.d.ts

@@ -0,0 +1,25 @@
+import { PostHogCore } from '../posthog-core';
+import type { JsonType, PostHogCoreOptions, PostHogFetchOptions, PostHogFetchResponse, PostHogFlagsResponse } from '../types';
+export interface PostHogCoreTestClientMocks {
+    fetch: jest.Mock<Promise<PostHogFetchResponse>, [string, PostHogFetchOptions]>;
+    storage: {
+        getItem: jest.Mock<any | undefined, [string]>;
+        setItem: jest.Mock<void, [string, any | null]>;
+    };
+}
+export declare class PostHogCoreTestClient extends PostHogCore {
+    private mocks;
+    _cachedDistinctId?: string;
+    constructor(mocks: PostHogCoreTestClientMocks, apiKey: string, options?: PostHogCoreOptions);
+    getFlags(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogFlagsResponse | undefined>;
+    getPersistedProperty<T>(key: string): T;
+    setPersistedProperty<T>(key: string, value: T | null): void;
+    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
+    getLibraryId(): string;
+    getLibraryVersion(): string;
+    getCustomUserAgent(): string;
+}
+export declare const createTestClient: (apiKey: string, options?: PostHogCoreOptions, setupMocks?: (mocks: PostHogCoreTestClientMocks) => void, storageCache?: {
+    [key: string]: string | JsonType;
+}) => [PostHogCoreTestClient, PostHogCoreTestClientMocks];
+//# sourceMappingURL=PostHogCoreTestClient.d.ts.map

node_modules/@posthog/core/dist/testing/PostHogCoreTestClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostHogCoreTestClient.d.ts","sourceRoot":"","sources":["../../src/testing/PostHogCoreTestClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAIhB,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAA;IAC9E,OAAO,EAAE;QACP,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC,CAAA;KAC/C,CAAA;CACF;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IAIlD,OAAO,CAAC,KAAK;IAHR,iBAAiB,CAAC,EAAE,MAAM,CAAA;gBAGvB,KAAK,EAAE,0BAA0B,EACzC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB;IAQvB,QAAQ,CACb,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAM,EAC5C,gBAAgB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAC7C,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,EAC5D,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACrC,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAI5C,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;IAGvC,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;IAG3D,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAG/E,YAAY,IAAI,MAAM;IAGtB,iBAAiB,IAAI,MAAM;IAG3B,kBAAkB,IAAI,MAAM;CAG7B;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,UAAU,kBAAkB,EAC5B,aAAa,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,EACxD,eAAc;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAA;CAAO,KACtD,CAAC,qBAAqB,EAAE,0BAA0B,CAsBpD,CAAA"}

node_modules/@posthog/core/dist/testing/PostHogCoreTestClient.js

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PostHogCoreTestClient: ()=>PostHogCoreTestClient,
+    createTestClient: ()=>createTestClient
+});
+const external_posthog_core_js_namespaceObject = require("../posthog-core.js");
+const version = '2.0.0-alpha';
+class PostHogCoreTestClient extends external_posthog_core_js_namespaceObject.PostHogCore {
+    constructor(mocks, apiKey, options){
+        super(apiKey, options), this.mocks = mocks;
+        this.setupBootstrap(options);
+    }
+    getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+        return super.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    }
+    getPersistedProperty(key) {
+        return this.mocks.storage.getItem(key);
+    }
+    setPersistedProperty(key, value) {
+        return this.mocks.storage.setItem(key, value);
+    }
+    fetch(url, options) {
+        return this.mocks.fetch(url, options);
+    }
+    getLibraryId() {
+        return 'posthog-core-tests';
+    }
+    getLibraryVersion() {
+        return version;
+    }
+    getCustomUserAgent() {
+        return 'posthog-core-tests';
+    }
+}
+const createTestClient = (apiKey, options, setupMocks, storageCache = {})=>{
+    const mocks = {
+        fetch: jest.fn(),
+        storage: {
+            getItem: jest.fn((key)=>storageCache[key]),
+            setItem: jest.fn((key, val)=>{
+                storageCache[key] = null == val ? void 0 : val;
+            })
+        }
+    };
+    mocks.fetch.mockImplementation(()=>Promise.resolve({
+            status: 200,
+            text: ()=>Promise.resolve('ok'),
+            json: ()=>Promise.resolve({
+                    status: 'ok'
+                })
+        }));
+    setupMocks?.(mocks);
+    return [
+        new PostHogCoreTestClient(mocks, apiKey, {
+            disableCompression: true,
+            ...options
+        }),
+        mocks
+    ];
+};
+exports.PostHogCoreTestClient = __webpack_exports__.PostHogCoreTestClient;
+exports.createTestClient = __webpack_exports__.createTestClient;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PostHogCoreTestClient",
+    "createTestClient"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

node_modules/@posthog/core/dist/testing/PostHogCoreTestClient.mjs

@@ -0,0 +1,56 @@
+import { PostHogCore } from "../posthog-core.mjs";
+const version = '2.0.0-alpha';
+class PostHogCoreTestClient extends PostHogCore {
+    constructor(mocks, apiKey, options){
+        super(apiKey, options), this.mocks = mocks;
+        this.setupBootstrap(options);
+    }
+    getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+        return super.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    }
+    getPersistedProperty(key) {
+        return this.mocks.storage.getItem(key);
+    }
+    setPersistedProperty(key, value) {
+        return this.mocks.storage.setItem(key, value);
+    }
+    fetch(url, options) {
+        return this.mocks.fetch(url, options);
+    }
+    getLibraryId() {
+        return 'posthog-core-tests';
+    }
+    getLibraryVersion() {
+        return version;
+    }
+    getCustomUserAgent() {
+        return 'posthog-core-tests';
+    }
+}
+const createTestClient = (apiKey, options, setupMocks, storageCache = {})=>{
+    const mocks = {
+        fetch: jest.fn(),
+        storage: {
+            getItem: jest.fn((key)=>storageCache[key]),
+            setItem: jest.fn((key, val)=>{
+                storageCache[key] = null == val ? void 0 : val;
+            })
+        }
+    };
+    mocks.fetch.mockImplementation(()=>Promise.resolve({
+            status: 200,
+            text: ()=>Promise.resolve('ok'),
+            json: ()=>Promise.resolve({
+                    status: 'ok'
+                })
+        }));
+    setupMocks?.(mocks);
+    return [
+        new PostHogCoreTestClient(mocks, apiKey, {
+            disableCompression: true,
+            ...options
+        }),
+        mocks
+    ];
+};
+export { PostHogCoreTestClient, createTestClient };

node_modules/@posthog/core/dist/testing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PostHogCoreTestClient';
+export * from './test-utils';
+//# sourceMappingURL=index.d.ts.map

node_modules/@posthog/core/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA"}

node_modules/@posthog/core/dist/testing/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_modules__ = {
+    "./PostHogCoreTestClient": function(module) {
+        module.exports = require("./PostHogCoreTestClient.js");
+    },
+    "./test-utils": function(module) {
+        module.exports = require("./test-utils.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _PostHogCoreTestClient__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./PostHogCoreTestClient");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _PostHogCoreTestClient__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _PostHogCoreTestClient__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _test_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./test-utils");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _test_utils__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _test_utils__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

node_modules/@posthog/core/dist/testing/index.mjs

@@ -0,0 +1,2 @@
+export * from "./PostHogCoreTestClient.mjs";
+export * from "./test-utils.mjs";

node_modules/@posthog/core/dist/testing/test-utils.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from '../types';
+export declare const wait: (t: number) => Promise<void>;
+export declare const waitForPromises: () => Promise<void>;
+export declare const parseBody: (mockCall: any) => any;
+export declare const createImperativePromise: <T>() => [Promise<T>, (value: T) => void];
+export declare const delay: (ms: number) => Promise<void>;
+export declare const createMockLogger: () => Logger;
+//# sourceMappingURL=test-utils.d.ts.map

node_modules/@posthog/core/dist/testing/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/testing/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhC,eAAO,MAAM,IAAI,GAAU,GAAG,MAAM,KAAG,OAAO,CAAC,IAAI,CAElD,CAAA;AAED,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,IAAI,CAQpD,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,GAAG,KAAG,GAIzC,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,CAAC,OAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAM5E,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAI9C,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,MAQnC,CAAA"}

node_modules/@posthog/core/dist/testing/test-utils.js

@@ -0,0 +1,85 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createImperativePromise: ()=>createImperativePromise,
+    createMockLogger: ()=>createMockLogger,
+    delay: ()=>delay,
+    parseBody: ()=>parseBody,
+    wait: ()=>wait,
+    waitForPromises: ()=>waitForPromises
+});
+const wait = async (t)=>{
+    await new Promise((r)=>setTimeout(r, t));
+};
+const waitForPromises = async ()=>{
+    await new Promise((resolve)=>{
+        jest.useRealTimers();
+        setTimeout(resolve, 10);
+        jest.useFakeTimers();
+    });
+};
+const parseBody = (mockCall)=>{
+    const options = mockCall[1];
+    expect(options.method).toBe('POST');
+    return JSON.parse(options.body || '');
+};
+const createImperativePromise = ()=>{
+    let resolve;
+    const promise = new Promise((r)=>{
+        resolve = r;
+    });
+    return [
+        promise,
+        (val)=>resolve?.(val)
+    ];
+};
+const delay = (ms)=>new Promise((resolve)=>{
+        setTimeout(resolve, ms);
+    });
+const createMockLogger = ()=>({
+        info: jest.fn((...args)=>console.log(...args)),
+        warn: jest.fn((...args)=>console.warn(...args)),
+        error: jest.fn((...args)=>console.error(...args)),
+        critical: jest.fn((...args)=>console.error(...args)),
+        createLogger: createMockLogger
+    });
+exports.createImperativePromise = __webpack_exports__.createImperativePromise;
+exports.createMockLogger = __webpack_exports__.createMockLogger;
+exports.delay = __webpack_exports__.delay;
+exports.parseBody = __webpack_exports__.parseBody;
+exports.wait = __webpack_exports__.wait;
+exports.waitForPromises = __webpack_exports__.waitForPromises;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createImperativePromise",
+    "createMockLogger",
+    "delay",
+    "parseBody",
+    "wait",
+    "waitForPromises"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

node_modules/@posthog/core/dist/testing/test-utils.mjs

@@ -0,0 +1,36 @@
+const wait = async (t)=>{
+    await new Promise((r)=>setTimeout(r, t));
+};
+const waitForPromises = async ()=>{
+    await new Promise((resolve)=>{
+        jest.useRealTimers();
+        setTimeout(resolve, 10);
+        jest.useFakeTimers();
+    });
+};
+const parseBody = (mockCall)=>{
+    const options = mockCall[1];
+    expect(options.method).toBe('POST');
+    return JSON.parse(options.body || '');
+};
+const createImperativePromise = ()=>{
+    let resolve;
+    const promise = new Promise((r)=>{
+        resolve = r;
+    });
+    return [
+        promise,
+        (val)=>resolve?.(val)
+    ];
+};
+const delay = (ms)=>new Promise((resolve)=>{
+        setTimeout(resolve, ms);
+    });
+const createMockLogger = ()=>({
+        info: jest.fn((...args)=>console.log(...args)),
+        warn: jest.fn((...args)=>console.warn(...args)),
+        error: jest.fn((...args)=>console.error(...args)),
+        critical: jest.fn((...args)=>console.error(...args)),
+        createLogger: createMockLogger
+    });
+export { createImperativePromise, createMockLogger, delay, parseBody, wait, waitForPromises };