posthog-node 5.8.8 → 5.9.1

package/dist/extensions/error-tracking/modifiers/context-lines.node.mjs

@@ -0,0 +1,187 @@
+import { ErrorTracking } from "@posthog/core";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+const LRU_FILE_CONTENTS_CACHE = new ErrorTracking.ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new ErrorTracking.ReduceableCache(20);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+const MAX_CONTEXTLINES_COLNO = 1000;
+const MAX_CONTEXTLINES_LINENO = 10000;
+async function addSourceContext(frames) {
+    const filesToLines = {};
+    for(let i = frames.length - 1; i >= 0; i--){
+        const frame = frames[i];
+        const filename = frame?.filename;
+        if (!frame || 'string' != typeof filename || 'number' != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
+        const filesToLinesOutput = filesToLines[filename];
+        if (!filesToLinesOutput) filesToLines[filename] = [];
+        filesToLines[filename].push(frame.lineno);
+    }
+    const files = Object.keys(filesToLines);
+    if (0 == files.length) return frames;
+    const readlinePromises = [];
+    for (const file of files){
+        if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) continue;
+        const filesToLineRanges = filesToLines[file];
+        if (!filesToLineRanges) continue;
+        filesToLineRanges.sort((a, b)=>a - b);
+        const ranges = makeLineReaderRanges(filesToLineRanges);
+        if (ranges.every((r)=>rangeExistsInContentCache(file, r))) continue;
+        const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
+        readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
+    }
+    await Promise.all(readlinePromises).catch(()=>{});
+    if (frames && frames.length > 0) addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
+    LRU_FILE_CONTENTS_CACHE.reduce();
+    return frames;
+}
+function getContextLinesFromFile(path, ranges, output) {
+    return new Promise((resolve)=>{
+        const stream = createReadStream(path);
+        const lineReaded = createInterface({
+            input: stream
+        });
+        function destroyStreamAndResolve() {
+            stream.destroy();
+            resolve();
+        }
+        let lineNumber = 0;
+        let currentRangeIndex = 0;
+        const range = ranges[currentRangeIndex];
+        if (void 0 === range) return void destroyStreamAndResolve();
+        let rangeStart = range[0];
+        let rangeEnd = range[1];
+        function onStreamError() {
+            LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);
+            lineReaded.close();
+            lineReaded.removeAllListeners();
+            destroyStreamAndResolve();
+        }
+        stream.on('error', onStreamError);
+        lineReaded.on('error', onStreamError);
+        lineReaded.on('close', destroyStreamAndResolve);
+        lineReaded.on('line', (line)=>{
+            lineNumber++;
+            if (lineNumber < rangeStart) return;
+            output[lineNumber] = snipLine(line, 0);
+            if (lineNumber >= rangeEnd) {
+                if (currentRangeIndex === ranges.length - 1) {
+                    lineReaded.close();
+                    lineReaded.removeAllListeners();
+                    return;
+                }
+                currentRangeIndex++;
+                const range = ranges[currentRangeIndex];
+                if (void 0 === range) {
+                    lineReaded.close();
+                    lineReaded.removeAllListeners();
+                    return;
+                }
+                rangeStart = range[0];
+                rangeEnd = range[1];
+            }
+        });
+    });
+}
+function addSourceContextToFrames(frames, cache) {
+    for (const frame of frames)if (frame.filename && void 0 === frame.context_line && 'number' == typeof frame.lineno) {
+        const contents = cache.get(frame.filename);
+        if (void 0 === contents) continue;
+        addContextToFrame(frame.lineno, frame, contents);
+    }
+}
+function addContextToFrame(lineno, frame, contents) {
+    if (void 0 === frame.lineno || void 0 === contents) return;
+    frame.pre_context = [];
+    for(let i = makeRangeStart(lineno); i < lineno; i++){
+        const line = contents[i];
+        if (void 0 === line) return void clearLineContext(frame);
+        frame.pre_context.push(line);
+    }
+    if (void 0 === contents[lineno]) return void clearLineContext(frame);
+    frame.context_line = contents[lineno];
+    const end = makeRangeEnd(lineno);
+    frame.post_context = [];
+    for(let i = lineno + 1; i <= end; i++){
+        const line = contents[i];
+        if (void 0 === line) break;
+        frame.post_context.push(line);
+    }
+}
+function clearLineContext(frame) {
+    delete frame.pre_context;
+    delete frame.context_line;
+    delete frame.post_context;
+}
+function shouldSkipContextLinesForFile(path) {
+    return path.startsWith('node:') || path.endsWith('.min.js') || path.endsWith('.min.cjs') || path.endsWith('.min.mjs') || path.startsWith('data:');
+}
+function shouldSkipContextLinesForFrame(frame) {
+    if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
+    if (void 0 !== frame.colno && frame.colno > MAX_CONTEXTLINES_COLNO) return true;
+    return false;
+}
+function rangeExistsInContentCache(file, range) {
+    const contents = LRU_FILE_CONTENTS_CACHE.get(file);
+    if (void 0 === contents) return false;
+    for(let i = range[0]; i <= range[1]; i++)if (void 0 === contents[i]) return false;
+    return true;
+}
+function makeLineReaderRanges(lines) {
+    if (!lines.length) return [];
+    let i = 0;
+    const line = lines[0];
+    if ('number' != typeof line) return [];
+    let current = makeContextRange(line);
+    const out = [];
+    while(true){
+        if (i === lines.length - 1) {
+            out.push(current);
+            break;
+        }
+        const next = lines[i + 1];
+        if ('number' != typeof next) break;
+        if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
+        else {
+            out.push(current);
+            current = makeContextRange(next);
+        }
+        i++;
+    }
+    return out;
+}
+function makeContextRange(line) {
+    return [
+        makeRangeStart(line),
+        makeRangeEnd(line)
+    ];
+}
+function makeRangeStart(line) {
+    return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
+}
+function makeRangeEnd(line) {
+    return line + DEFAULT_LINES_OF_CONTEXT;
+}
+function emplace(map, key, contents) {
+    const value = map.get(key);
+    if (void 0 === value) {
+        map.set(key, contents);
+        return contents;
+    }
+    return value;
+}
+function snipLine(line, colno) {
+    let newLine = line;
+    const lineLength = newLine.length;
+    if (lineLength <= 150) return newLine;
+    if (colno > lineLength) colno = lineLength;
+    let start = Math.max(colno - 60, 0);
+    if (start < 5) start = 0;
+    let end = Math.min(start + 140, lineLength);
+    if (end > lineLength - 5) end = lineLength;
+    if (end === lineLength) start = Math.max(end - 140, 0);
+    newLine = newLine.slice(start, end);
+    if (start > 0) newLine = `...${newLine}`;
+    if (end < lineLength) newLine += '...';
+    return newLine;
+}
+export { MAX_CONTEXTLINES_COLNO, MAX_CONTEXTLINES_LINENO, addSourceContext };

package/dist/extensions/error-tracking/modifiers/module.node.d.ts

@@ -0,0 +1,3 @@
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+export declare function createModulerModifier(): (frames: CoreErrorTracking.StackFrame[]) => Promise<CoreErrorTracking.StackFrame[]>;
+//# sourceMappingURL=module.node.d.ts.map

package/dist/extensions/error-tracking/modifiers/module.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.node.d.ts","sourceRoot":"","sources":["../../../../src/extensions/error-tracking/modifiers/module.node.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAGlE,wBAAgB,qBAAqB,KAErB,QAAQ,iBAAiB,CAAC,UAAU,EAAE,KAAG,OAAO,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAC,CAM/F"}

package/dist/extensions/error-tracking/modifiers/module.node.js

@@ -0,0 +1,64 @@
+"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__, {
+    createModulerModifier: ()=>createModulerModifier
+});
+const external_path_namespaceObject = require("path");
+function createModulerModifier() {
+    const getModuleFromFileName = createGetModuleFromFilename();
+    return async (frames)=>{
+        for (const frame of frames)frame.module = getModuleFromFileName(frame.filename);
+        return frames;
+    };
+}
+function createGetModuleFromFilename(basePath = process.argv[1] ? (0, external_path_namespaceObject.dirname)(process.argv[1]) : process.cwd(), isWindows = '\\' === external_path_namespaceObject.sep) {
+    const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+    return (filename)=>{
+        if (!filename) return;
+        const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+        let { dir, base: file, ext } = external_path_namespaceObject.posix.parse(normalizedFilename);
+        if ('.js' === ext || '.mjs' === ext || '.cjs' === ext) file = file.slice(0, -1 * ext.length);
+        const decodedFile = decodeURIComponent(file);
+        if (!dir) dir = '.';
+        const n = dir.lastIndexOf('/node_modules');
+        if (n > -1) return `${dir.slice(n + 14).replace(/\//g, '.')}:${decodedFile}`;
+        if (dir.startsWith(normalizedBase)) {
+            const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+            return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+        }
+        return decodedFile;
+    };
+}
+function normalizeWindowsPath(path) {
+    return path.replace(/^[A-Z]:/, '').replace(/\\/g, '/');
+}
+exports.createModulerModifier = __webpack_exports__.createModulerModifier;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createModulerModifier"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/modifiers/module.node.mjs

@@ -0,0 +1,30 @@
+import { dirname, posix, sep } from "path";
+function createModulerModifier() {
+    const getModuleFromFileName = createGetModuleFromFilename();
+    return async (frames)=>{
+        for (const frame of frames)frame.module = getModuleFromFileName(frame.filename);
+        return frames;
+    };
+}
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(process.argv[1]) : process.cwd(), isWindows = '\\' === sep) {
+    const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+    return (filename)=>{
+        if (!filename) return;
+        const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+        let { dir, base: file, ext } = posix.parse(normalizedFilename);
+        if ('.js' === ext || '.mjs' === ext || '.cjs' === ext) file = file.slice(0, -1 * ext.length);
+        const decodedFile = decodeURIComponent(file);
+        if (!dir) dir = '.';
+        const n = dir.lastIndexOf('/node_modules');
+        if (n > -1) return `${dir.slice(n + 14).replace(/\//g, '.')}:${decodedFile}`;
+        if (dir.startsWith(normalizedBase)) {
+            const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+            return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+        }
+        return decodedFile;
+    };
+}
+function normalizeWindowsPath(path) {
+    return path.replace(/^[A-Z]:/, '').replace(/\\/g, '/');
+}
+export { createModulerModifier };

package/dist/extensions/express.d.ts

@@ -0,0 +1,17 @@
+import type * as http from 'node:http';
+import { PostHogBackendClient } from '../client';
+type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void;
+type ExpressErrorMiddleware = (error: MiddlewareError, req: http.IncomingMessage, res: http.ServerResponse, next: (error: MiddlewareError) => void) => void;
+interface MiddlewareError extends Error {
+    status?: number | string;
+    statusCode?: number | string;
+    status_code?: number | string;
+    output?: {
+        statusCode?: number | string;
+    };
+}
+export declare function setupExpressErrorHandler(_posthog: PostHogBackendClient, app: {
+    use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown;
+}): void;
+export {};
+//# sourceMappingURL=express.d.ts.map

package/dist/extensions/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../src/extensions/express.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AAGtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAGhD,KAAK,iBAAiB,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;AAExG,KAAK,sBAAsB,GAAG,CAC5B,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,IAAI,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,KACnC,IAAI,CAAA;AAET,UAAU,eAAgB,SAAQ,KAAK;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC7B,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAC7B,CAAA;CACF;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,oBAAoB,EAC9B,GAAG,EAAE;IACH,GAAG,EAAE,CAAC,UAAU,EAAE,iBAAiB,GAAG,sBAAsB,KAAK,OAAO,CAAA;CACzE,GACA,IAAI,CAUN"}

package/dist/extensions/express.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    setupExpressErrorHandler: ()=>setupExpressErrorHandler
+});
+const core_namespaceObject = require("@posthog/core");
+const index_js_namespaceObject = require("./error-tracking/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+function setupExpressErrorHandler(_posthog, app) {
+    app.use((error, _, __, next)=>{
+        const hint = {
+            mechanism: {
+                type: 'middleware',
+                handled: false
+            }
+        };
+        index_js_default().buildEventMessage(error, hint, (0, core_namespaceObject.uuidv7)(), {
+            $process_person_profile: false
+        }).then((msg)=>_posthog.capture(msg));
+        next(error);
+    });
+}
+exports.setupExpressErrorHandler = __webpack_exports__.setupExpressErrorHandler;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "setupExpressErrorHandler"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/express.mjs

@@ -0,0 +1,17 @@
+import { uuidv7 } from "@posthog/core";
+import error_tracking from "./error-tracking/index.mjs";
+function setupExpressErrorHandler(_posthog, app) {
+    app.use((error, _, __, next)=>{
+        const hint = {
+            mechanism: {
+                type: 'middleware',
+                handled: false
+            }
+        };
+        error_tracking.buildEventMessage(error, hint, uuidv7(), {
+            $process_person_profile: false
+        }).then((msg)=>_posthog.capture(msg));
+        next(error);
+    });
+}
+export { setupExpressErrorHandler };

package/dist/extensions/feature-flags/crypto-helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function getNodeCrypto(): Promise<typeof import('crypto') | undefined>;
+export declare function getWebCrypto(): Promise<SubtleCrypto | undefined>;
+//# sourceMappingURL=crypto-helpers.d.ts.map

package/dist/extensions/feature-flags/crypto-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-helpers.d.ts","sourceRoot":"","sources":["../../../src/extensions/feature-flags/crypto-helpers.ts"],"names":[],"mappings":"AAWA,wBAAsB,aAAa,IAAI,OAAO,CAAC,cAAc,QAAQ,CAAC,GAAG,SAAS,CAAC,CAElF;AAoBD,wBAAsB,YAAY,IAAI,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAEtE"}

package/dist/extensions/feature-flags/crypto-helpers.js

@@ -0,0 +1,77 @@
+"use strict";
+var __webpack_modules__ = {
+    crypto: function(module) {
+        module.exports = import("crypto").then(function(module) {
+            return module;
+        });
+    }
+};
+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__.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__, {
+        getNodeCrypto: ()=>getNodeCrypto,
+        getWebCrypto: ()=>getWebCrypto
+    });
+    const external_lazy_js_namespaceObject = require("./lazy.js");
+    const nodeCrypto = new external_lazy_js_namespaceObject.Lazy(async ()=>{
+        try {
+            return await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "crypto"));
+        } catch  {
+            return;
+        }
+    });
+    async function getNodeCrypto() {
+        return await nodeCrypto.getValue();
+    }
+    const webCrypto = new external_lazy_js_namespaceObject.Lazy(async ()=>{
+        if (void 0 !== globalThis.crypto?.subtle) return globalThis.crypto.subtle;
+        try {
+            const crypto = await nodeCrypto.getValue();
+            if (crypto?.webcrypto?.subtle) return crypto.webcrypto.subtle;
+        } catch  {}
+    });
+    async function getWebCrypto() {
+        return await webCrypto.getValue();
+    }
+})();
+exports.getNodeCrypto = __webpack_exports__.getNodeCrypto;
+exports.getWebCrypto = __webpack_exports__.getWebCrypto;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getNodeCrypto",
+    "getWebCrypto"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/feature-flags/crypto-helpers.mjs

@@ -0,0 +1,22 @@
+import { Lazy } from "./lazy.mjs";
+const nodeCrypto = new Lazy(async ()=>{
+    try {
+        return await import("crypto");
+    } catch  {
+        return;
+    }
+});
+async function getNodeCrypto() {
+    return await nodeCrypto.getValue();
+}
+const webCrypto = new Lazy(async ()=>{
+    if (void 0 !== globalThis.crypto?.subtle) return globalThis.crypto.subtle;
+    try {
+        const crypto = await nodeCrypto.getValue();
+        if (crypto?.webcrypto?.subtle) return crypto.webcrypto.subtle;
+    } catch  {}
+});
+async function getWebCrypto() {
+    return await webCrypto.getValue();
+}
+export { getNodeCrypto, getWebCrypto };

package/dist/extensions/feature-flags/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function hashSHA1(text: string): Promise<string>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/extensions/feature-flags/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/extensions/feature-flags/crypto.ts"],"names":[],"mappings":"AAIA,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB5D"}

package/dist/extensions/feature-flags/crypto.js

@@ -0,0 +1,47 @@
+"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__, {
+    hashSHA1: ()=>hashSHA1
+});
+const external_crypto_helpers_js_namespaceObject = require("./crypto-helpers.js");
+async function hashSHA1(text) {
+    const nodeCrypto = await (0, external_crypto_helpers_js_namespaceObject.getNodeCrypto)();
+    if (nodeCrypto) return nodeCrypto.createHash('sha1').update(text).digest('hex');
+    const webCrypto = await (0, external_crypto_helpers_js_namespaceObject.getWebCrypto)();
+    if (webCrypto) {
+        const hashBuffer = await webCrypto.digest('SHA-1', new TextEncoder().encode(text));
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+    }
+    throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API');
+}
+exports.hashSHA1 = __webpack_exports__.hashSHA1;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "hashSHA1"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/feature-flags/crypto.mjs

@@ -0,0 +1,13 @@
+import { getNodeCrypto, getWebCrypto } from "./crypto-helpers.mjs";
+async function hashSHA1(text) {
+    const nodeCrypto = await getNodeCrypto();
+    if (nodeCrypto) return nodeCrypto.createHash('sha1').update(text).digest('hex');
+    const webCrypto = await getWebCrypto();
+    if (webCrypto) {
+        const hashBuffer = await webCrypto.digest('SHA-1', new TextEncoder().encode(text));
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+    }
+    throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API');
+}
+export { hashSHA1 };

package/dist/extensions/feature-flags/feature-flags.d.ts

@@ -0,0 +1,89 @@
+import { FeatureFlagCondition, PostHogFeatureFlag, PropertyGroup } from '../../types';
+import type { FeatureFlagValue, JsonType, PostHogFetchOptions, PostHogFetchResponse } from '@posthog/core';
+declare class ClientError extends Error {
+    constructor(message: string);
+}
+declare class InconclusiveMatchError extends Error {
+    constructor(message: string);
+}
+type FeatureFlagsPollerOptions = {
+    personalApiKey: string;
+    projectApiKey: string;
+    host: string;
+    pollingInterval: number;
+    timeout?: number;
+    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+    onError?: (error: Error) => void;
+    onLoad?: (count: number) => void;
+    customHeaders?: {
+        [key: string]: string;
+    };
+};
+declare class FeatureFlagsPoller {
+    pollingInterval: number;
+    personalApiKey: string;
+    projectApiKey: string;
+    featureFlags: Array<PostHogFeatureFlag>;
+    featureFlagsByKey: Record<string, PostHogFeatureFlag>;
+    groupTypeMapping: Record<string, string>;
+    cohorts: Record<string, PropertyGroup>;
+    loadedSuccessfullyOnce: boolean;
+    timeout?: number;
+    host: FeatureFlagsPollerOptions['host'];
+    poller?: NodeJS.Timeout;
+    fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+    debugMode: boolean;
+    onError?: (error: Error) => void;
+    customHeaders?: {
+        [key: string]: string;
+    };
+    shouldBeginExponentialBackoff: boolean;
+    backOffCount: number;
+    onLoad?: (count: number) => void;
+    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }: FeatureFlagsPollerOptions);
+    debug(enabled?: boolean): void;
+    private logMsgIfDebug;
+    getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<FeatureFlagValue | undefined>;
+    getAllFlagsAndPayloads(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, flagKeysToExplicitlyEvaluate?: string[]): Promise<{
+        response: Record<string, FeatureFlagValue>;
+        payloads: Record<string, JsonType>;
+        fallbackToFlags: boolean;
+    }>;
+    computeFlagAndPayloadLocally(flag: PostHogFeatureFlag, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, matchValue?: FeatureFlagValue, evaluationCache?: Record<string, FeatureFlagValue>, skipLoadCheck?: boolean): Promise<{
+        value: FeatureFlagValue;
+        payload: JsonType | null;
+    }>;
+    private computeFlagValueLocally;
+    private getFeatureFlagPayload;
+    private evaluateFlagDependency;
+    private flagEvaluatesToExpectedValue;
+    matchFeatureFlagProperties(flag: PostHogFeatureFlag, distinctId: string, properties: Record<string, string>, evaluationCache?: Record<string, FeatureFlagValue>): Promise<FeatureFlagValue>;
+    isConditionMatch(flag: PostHogFeatureFlag, distinctId: string, condition: FeatureFlagCondition, properties: Record<string, string>, evaluationCache?: Record<string, FeatureFlagValue>): Promise<boolean>;
+    getMatchingVariant(flag: PostHogFeatureFlag, distinctId: string): Promise<FeatureFlagValue | undefined>;
+    variantLookupTable(flag: PostHogFeatureFlag): {
+        valueMin: number;
+        valueMax: number;
+        key: string;
+    }[];
+    loadFeatureFlags(forceReload?: boolean): Promise<void>;
+    /**
+     * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
+     * This is useful to check if local evaluation is ready before calling getFeatureFlag.
+     */
+    isLocalEvaluationReady(): boolean;
+    /**
+     * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
+     * until a successful request is made, up to a maximum of 60 seconds.
+     *
+     * @returns The polling interval to use for the next request.
+     */
+    private getPollingInterval;
+    _loadFeatureFlags(): Promise<void>;
+    private getPersonalApiKeyRequestOptions;
+    _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse>;
+    stopPoller(): void;
+}
+declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>, warnFunction?: (msg: string) => void): boolean;
+declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;
+export { FeatureFlagsPoller, matchProperty, relativeDateParseForFeatureFlagMatching, InconclusiveMatchError, ClientError, };
+//# sourceMappingURL=feature-flags.d.ts.map