@logicflow/engine 0.0.10-beta.0 → 0.0.11-beta.0

package/es/nodes/BaseNode.js

@@ -0,0 +1,250 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { ActionStatus } from '../constant/constant';
+import { getExpressionResult } from '../expression';
+var BaseNode = /** @class */ (function () {
+    function BaseNode(_a) {
+        var nodeConfig = _a.nodeConfig, context = _a.context, globalData = _a.globalData;
+        this.outgoing = nodeConfig.outgoing;
+        this.incoming = nodeConfig.incoming;
+        this.nodeId = nodeConfig.id;
+        this.type = nodeConfig.type;
+        this.properties = nodeConfig.properties || {};
+        this.context = context;
+        this.globalData = globalData;
+        this.baseType = 'base';
+    }
+    /**
+     * 节点的每一次执行都会生成一个唯一的actionId
+     */
+    BaseNode.prototype.execute = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var r, status, outgoing, detail;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.action({
+                            executionId: params.executionId,
+                            actionId: params.actionId,
+                            nodeId: this.nodeId,
+                        })];
+                    case 1:
+                        r = _a.sent();
+                        status = r ? r.status : 'success';
+                        if (!(status === ActionStatus.SUCCESS)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.getOutgoing()];
+                    case 2:
+                        outgoing = _a.sent();
+                        detail = r ? r.detail : {};
+                        params.next({
+                            status: ActionStatus.SUCCESS,
+                            detail: detail,
+                            executionId: params.executionId,
+                            actionId: params.actionId,
+                            nodeId: this.nodeId,
+                            nodeType: this.type,
+                            properties: this.properties,
+                            outgoing: outgoing,
+                        });
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, {
+                            status: status,
+                            detail: r && r.detail,
+                            executionId: params.executionId,
+                            actionId: params.actionId,
+                            nodeId: this.nodeId,
+                            nodeType: this.type,
+                            properties: this.properties,
+                            outgoing: [],
+                        }];
+                }
+            });
+        });
+    };
+    /**
+     * 节点在执行中断后，可以通过resume方法恢复执行。
+     * 自定义节点时不建议重写此方法
+     */
+    BaseNode.prototype.resume = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var outgoing;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getOutgoing()];
+                    case 1:
+                        outgoing = _a.sent();
+                        return [4 /*yield*/, this.onResume({
+                                executionId: params.executionId,
+                                nodeId: params.nodeId,
+                                actionId: params.actionId,
+                                data: params.data,
+                            })];
+                    case 2:
+                        _a.sent();
+                        params.next({
+                            executionId: params.executionId,
+                            actionId: params.actionId,
+                            nodeId: this.nodeId,
+                            nodeType: this.type,
+                            properties: this.properties,
+                            outgoing: outgoing,
+                            status: ActionStatus.SUCCESS,
+                        });
+                        return [2 /*return*/, undefined];
+                }
+            });
+        });
+    };
+    BaseNode.prototype.getOutgoing = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var outgoing, expressions, _a, _b, item, properties, result;
+            var e_1, _c;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        outgoing = [];
+                        expressions = [];
+                        try {
+                            for (_a = __values(this.outgoing), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                item = _b.value;
+                                properties = item.properties;
+                                expressions.push(this.isPass(properties));
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return [4 /*yield*/, Promise.all(expressions)];
+                    case 1:
+                        result = _d.sent();
+                        result.forEach(function (item, index) {
+                            var out = _this.outgoing[index];
+                            out.result = item;
+                            outgoing.push(out);
+                        });
+                        return [2 /*return*/, outgoing];
+                }
+            });
+        });
+    };
+    BaseNode.prototype.isPass = function (properties) {
+        return __awaiter(this, void 0, void 0, function () {
+            var conditionExpression, result, e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!properties)
+                            return [2 /*return*/, true];
+                        conditionExpression = properties.conditionExpression;
+                        if (!conditionExpression)
+                            return [2 /*return*/, true];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, getExpressionResult("isPassResult = (" + conditionExpression + ")", __assign({}, this.globalData))];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result.isPassResult];
+                    case 3:
+                        e_2 = _a.sent();
+                        return [2 /*return*/, false];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 节点的执行逻辑
+     * @overridable 可以自定义节点重写此方法。
+     * @param params.executionId 流程执行记录ID
+     * @param params.actionId 此节点执行记录ID
+     * @param params.nodeId 节点ID
+     * @returns 返回下一步的执行参数
+     * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
+     * 当返回时，返回格式
+     */
+    BaseNode.prototype.action = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, null];
+            });
+        });
+    };
+    /**
+     * 节点的重新恢复执行逻辑
+     * @overridable 可以自定义节点重写此方法。
+     * @param params.executionId 流程执行记录ID
+     * @param params.actionId 此节点执行记录ID
+     * @param params.nodeId 节点ID
+     */
+    BaseNode.prototype.onResume = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    BaseNode.nodeTypeName = 'BaseNode';
+    return BaseNode;
+}());
+export default BaseNode;

package/es/nodes/{start.d.ts → StartNode.d.ts}

@@ -1,6 +1,5 @@
-import BaseNode from './base';
+import BaseNode from './BaseNode';
 export default class StartNode extends BaseNode {
-    readonly baseType = "start";
     static nodeTypeName: string;
+    readonly baseType = "start";
 }
-export { StartNode };

package/es/nodes/StartNode.js

@@ -0,0 +1,25 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import BaseNode from './BaseNode';
+var StartNode = /** @class */ (function (_super) {
+    __extends(StartNode, _super);
+    function StartNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.baseType = 'start';
+        return _this;
+    }
+    StartNode.nodeTypeName = 'StartNode';
+    return StartNode;
+}(BaseNode));
+export default StartNode;

package/es/nodes/{task.d.ts → TaskNode.d.ts}

@@ -1,6 +1,5 @@
-import BaseNode from './base';
+import BaseNode from './BaseNode';
 export default class TaskNode extends BaseNode {
-    readonly baseType = "task";
     static nodeTypeName: string;
+    readonly baseType = "task";
 }
-export { TaskNode };

package/es/nodes/TaskNode.js

@@ -0,0 +1,25 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import BaseNode from './BaseNode';
+var TaskNode = /** @class */ (function (_super) {
+    __extends(TaskNode, _super);
+    function TaskNode() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.baseType = 'task';
+        return _this;
+    }
+    TaskNode.nodeTypeName = 'TaskNode';
+    return TaskNode;
+}(BaseNode));
+export default TaskNode;

package/es/recorder/index.d.ts

@@ -1,46 +1,20 @@
-import { Engine } from '..';
-export declare const MAX_RECORDER = 100;
-export declare const MAX_INSTANCE = 100;
-export declare const LOGICFLOW_ENGINE_INSTANCES = "LOGICFLOW_ENGINE_INSTANCES";
-export declare class Recorder implements Recorder.Base {
-    instanceId: Engine.Key;
+import type { RecorderData, RecorderInterface } from '../types.d';
+export default class Recorder implements RecorderInterface {
     maxRecorder: number;
+    instanceId: number;
     constructor({ instanceId }: {
         instanceId: any;
     });
-    setMaxRecorderNumber(max: number): void;
+    setMaxRecorderNumber(maxRecorder: number): void;
     setItem(key: string | number, value: unknown): void;
     getItem(key: string | number): any;
-    getExecutionActions(executionId: Engine.Key): Promise<any>;
+    addActionRecord(action: RecorderData): Promise<void>;
+    getActionRecord(actionId: string): Promise<RecorderData>;
+    getExecutionActions(executionId: any): Promise<any>;
     getExecutionList(): Promise<any>;
-    private addExecution;
+    clear(): void;
+    clearInstance(instanceId: any): void;
+    private pushExecution;
     private popExecution;
     private pushActionToExecution;
-    /**
-     * @param {Object} action
-     * {
-     *   actionId: '',
-     *   nodeId: '',
-     *   executionId: '',
-     *   nodeType: '',
-     *   timestamp: '',
-     *   properties: {},
-     * }
-     */
-    addActionRecord(action: Recorder.Info): Promise<void>;
-    getActionRecord(actionId: Engine.Key): Promise<Recorder.Info>;
-    clear(): void;
-    clearInstance(instanceId: Engine.Key): void;
-}
-export declare namespace Recorder {
-    interface Base {
-        addActionRecord: (action: Info) => Promise<void>;
-        getActionRecord: (actionId: Engine.Key) => Promise<Info>;
-        getExecutionActions: (executionId: Engine.Key) => Promise<string[]>;
-        clear: () => void;
-    }
-    type Info = {
-        timestamp: number;
-    } & Engine.NextActionParam;
 }
-export default Recorder;

package/es/recorder/index.js

@@ -1,113 +1,166 @@
-import { __awaiter } from "tslib";
-import { storage } from '../utils';
-export const MAX_RECORDER = 100;
-export const MAX_INSTANCE = 100;
-export const LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES';
-export class Recorder {
-    constructor({ instanceId }) {
-        this.instanceId = instanceId;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import storage from '../util/storage';
+var LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES';
+var MAX_RECORDER = 100;
+var MAX_INSTANCE = 100;
+var Recorder = /** @class */ (function () {
+    function Recorder(_a) {
+        var instanceId = _a.instanceId;
         this.maxRecorder = MAX_RECORDER;
-        const instances = this.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        this.instanceId = instanceId;
+        var instances = this.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
         if (instances.indexOf(instanceId) === -1) {
             instances.push(instanceId);
         }
         if (instances.length > MAX_INSTANCE) {
-            const clearInstance = instances.shift();
+            var clearInstance = instances.shift();
             this.clearInstance(clearInstance);
         }
         this.setItem(LOGICFLOW_ENGINE_INSTANCES, instances);
     }
-    setMaxRecorderNumber(max) {
-        this.maxRecorder = max;
-    }
+    Recorder.prototype.setMaxRecorderNumber = function (maxRecorder) {
+        this.maxRecorder = maxRecorder;
+    };
     // 将存储 storage 的方法收敛到此处，并在此处做异常处理 - setItem
-    setItem(key, value) {
+    Recorder.prototype.setItem = function (key, value) {
         try {
             storage.setItem(key, value);
         }
         catch (error) {
-            console.error('Ops, something wrong with storage.setItem !!!');
+            console.log('Ops, something wrong with storage.setItem');
             storage.clear();
             storage.setItem(key, value);
         }
-    }
+    };
     // getItem 方法
-    getItem(key) {
+    Recorder.prototype.getItem = function (key) {
         return storage.getItem(key);
-    }
-    getExecutionActions(executionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getItem(executionId);
+    };
+    /*
+    * @param {Object} action
+    * {
+    *   actionId: '',
+    *   nodeId: '',
+    *   executionId: '',
+    *   nodeType: '',
+    *   timestamp: '',
+    *   properties: {},
+    * }
+    */
+    Recorder.prototype.addActionRecord = function (action) {
+        return __awaiter(this, void 0, void 0, function () {
+            var executionId, actionId, instanceData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        executionId = action.executionId, actionId = action.actionId;
+                        return [4 /*yield*/, this.getExecutionActions(executionId)];
+                    case 1:
+                        instanceData = _a.sent();
+                        if (!instanceData) {
+                            this.pushExecution(executionId);
+                        }
+                        this.pushActionToExecution(executionId, actionId);
+                        this.setItem(actionId, action);
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
-    getExecutionList() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getItem(this.instanceId) || [];
+    };
+    Recorder.prototype.getActionRecord = function (actionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getItem(actionId)];
+            });
         });
-    }
-    addExecution(executionId) {
-        const instanceExecutions = this.getItem(this.instanceId) || [];
+    };
+    Recorder.prototype.getExecutionActions = function (executionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getItem(executionId)];
+            });
+        });
+    };
+    Recorder.prototype.getExecutionList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var instances;
+            return __generator(this, function (_a) {
+                instances = this.getItem(this.instanceId) || [];
+                return [2 /*return*/, instances];
+            });
+        });
+    };
+    Recorder.prototype.clear = function () {
+        this.clearInstance(this.instanceId);
+    };
+    Recorder.prototype.clearInstance = function (instanceId) {
+        var _this = this;
+        var instanceExecutions = this.getItem(instanceId) || [];
+        instanceExecutions.forEach(function (executionId) {
+            storage.removeItem(executionId);
+            var instanceData = _this.getItem(executionId) || [];
+            instanceData.forEach(function (actionId) {
+                storage.removeItem(actionId);
+            });
+        });
+        storage.removeItem(instanceId);
+    };
+    Recorder.prototype.pushExecution = function (executionId) {
+        var instanceExecutions = this.getItem(this.instanceId) || [];
         if (instanceExecutions.length >= this.maxRecorder) {
-            const toBeRemovedItem = instanceExecutions.shift();
-            this.popExecution(toBeRemovedItem);
+            var removeItem = instanceExecutions.shift();
+            this.popExecution(removeItem);
         }
         instanceExecutions.push(executionId);
         this.setItem(this.instanceId, instanceExecutions);
-    }
-    popExecution(executionId) {
-        const instanceData = this.getItem(executionId) || [];
-        instanceData.forEach((actionId) => {
+    };
+    Recorder.prototype.popExecution = function (executionId) {
+        var instanceData = this.getItem(executionId) || [];
+        instanceData.forEach(function (actionId) {
             storage.removeItem(actionId);
         });
         storage.removeItem(executionId);
-    }
-    pushActionToExecution(executionId, actionId) {
-        const actions = this.getItem(executionId) || [];
+    };
+    Recorder.prototype.pushActionToExecution = function (executionId, actionId) {
+        var actions = this.getItem(executionId) || [];
         actions.push(actionId);
         this.setItem(executionId, actions);
-    }
-    /**
-     * @param {Object} action
-     * {
-     *   actionId: '',
-     *   nodeId: '',
-     *   executionId: '',
-     *   nodeType: '',
-     *   timestamp: '',
-     *   properties: {},
-     * }
-     */
-    addActionRecord(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { executionId, actionId } = action;
-            const instanceData = yield this.getExecutionActions(executionId);
-            if (!instanceData) {
-                this.addExecution(executionId);
-            }
-            this.pushActionToExecution(executionId, actionId);
-            this.setItem(actionId, action);
-        });
-    }
-    getActionRecord(actionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getItem(actionId);
-        });
-    }
-    clear() {
-        this.clearInstance(this.instanceId);
-    }
-    clearInstance(instanceId) {
-        const instanceExecutions = this.getItem(instanceId) || [];
-        // TODO: 完善类型定义
-        instanceExecutions.forEach((executionId) => {
-            storage.removeItem(executionId);
-            const instanceData = this.getItem(executionId) || [];
-            instanceData.forEach((actionId) => {
-                storage.removeItem(actionId);
-            });
-        });
-        storage.removeItem(instanceId);
-    }
-}
+    };
+    return Recorder;
+}());
 export default Recorder;
-//# sourceMappingURL=index.js.map

package/es/util/ID.js

@@ -0,0 +1,13 @@
+import { v4 as uuidv4 } from 'uuid';
+export var createExecId = function () {
+    var uuid = uuidv4();
+    return "exec-" + uuid;
+};
+export var createActionId = function () {
+    var uuid = uuidv4();
+    return "action-" + uuid;
+};
+export var createEngineId = function () {
+    var uuid = uuidv4();
+    return "engine-" + uuid;
+};

package/es/util/global.d.ts

@@ -0,0 +1,5 @@
+declare const isInBrowser: boolean;
+declare const isInNodeJS: boolean;
+declare const isInWebWorker: Function;
+declare const globalScope: Record<string, any>;
+export { globalScope, isInBrowser, isInWebWorker, isInNodeJS, };