@hotmeshio/hotmesh 0.3.32 → 0.4.0

package/build/services/meshflow/client.d.ts

@@ -1,108 +0,0 @@
-import { HotMesh } from '../hotmesh';
-import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/meshflow';
-/**
- * The MeshFlow `Client` service is functionally
- * equivalent to the Temporal `Client` service.
- * Start a new workflow execution by calling
- * `workflow.start`. Note the direct connection to
- * Postgres.
- *
- * NATS can be used as the message broker if advanced
- * messaging is required (i.e, patterned subscriptions).
- * @example
-
- * ```typescript
- * //client.ts
- * import { Client, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres } from 'pg';
-
- * async function run(): Promise<string> {
- *   const client = new Client({
- *     connection: {
- *       class: Postgres,
- *       options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
- *     }
- *   });
-
- *   const handle = await client.workflow.start({
- *     args: ['HotMesh'],
- *     taskQueue: 'default',
- *     workflowName: 'example',
- *     workflowId: HotMesh.guid()
- *   });
-
- *   return await handle.result();
- *   //returns ['Hello HotMesh', '¡Hola, HotMesh!']
- * }
- * ```
- */
-export declare class ClientService {
-    /**
-     * @private
-     */
-    connection: Connection;
-    /**
-     * @private
-     */
-    options: WorkflowOptions;
-    /**
-     * @private
-     */
-    static topics: string[];
-    /**
-     * @private
-     */
-    static instances: Map<string, HotMesh | Promise<HotMesh>>;
-    /**
-     * @private
-     */
-    constructor(config: ClientConfig);
-    /**
-     * @private
-     */
-    getHotMeshClient: (workflowTopic: string | null, namespace?: string) => Promise<HotMesh>;
-    /**
-     * Creates a stream where messages can be published to ensure there is a
-     * channel in place when the message arrives (a race condition for those
-     * platforms without implicit topic setup).
-     * @private
-     */
-    static createStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
-    hashOptions(): string;
-    /**
-     * It is possible for a client to invoke a workflow without first
-     * creating the stream. This method will verify that the stream
-     * exists and if not, create it.
-     * @private
-     */
-    verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
-    /**
-     * @private
-     */
-    search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
-    /**
-     * The MeshFlow `Client` service is functionally
-     * equivalent to the Temporal `Client` service.
-     * Starting a workflow is the primary use case and
-     * is accessed by calling workflow.start().
-     */
-    workflow: ClientWorkflow;
-    /**
-     * Any router can be used to deploy and activate the HotMesh
-     * distributed executable to the active quorum EXCEPT for
-     * those routers in `readonly` mode.
-     */
-    deployAndActivate(namespace?: string, version?: string): Promise<void>;
-    /**
-     * @private
-     */
-    verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
-    /**
-     * @private
-     */
-    activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
-    /**
-     * @private
-     */
-    static shutdown(): Promise<void>;
-}

package/build/services/meshflow/client.js

@@ -1,371 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientService = void 0;
-const enums_1 = require("../../modules/enums");
-const utils_1 = require("../../modules/utils");
-const hotmesh_1 = require("../hotmesh");
-const key_1 = require("../../modules/key");
-const types_1 = require("../../types");
-const search_1 = require("./search");
-const handle_1 = require("./handle");
-const factory_1 = require("./schemas/factory");
-/**
- * The MeshFlow `Client` service is functionally
- * equivalent to the Temporal `Client` service.
- * Start a new workflow execution by calling
- * `workflow.start`. Note the direct connection to
- * Postgres.
- *
- * NATS can be used as the message broker if advanced
- * messaging is required (i.e, patterned subscriptions).
- * @example
-
- * ```typescript
- * //client.ts
- * import { Client, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres } from 'pg';
-
- * async function run(): Promise<string> {
- *   const client = new Client({
- *     connection: {
- *       class: Postgres,
- *       options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
- *     }
- *   });
-
- *   const handle = await client.workflow.start({
- *     args: ['HotMesh'],
- *     taskQueue: 'default',
- *     workflowName: 'example',
- *     workflowId: HotMesh.guid()
- *   });
-
- *   return await handle.result();
- *   //returns ['Hello HotMesh', '¡Hola, HotMesh!']
- * }
- * ```
- */
-class ClientService {
-    /**
-     * @private
-     */
-    constructor(config) {
-        /**
-         * @private
-         */
-        this.getHotMeshClient = async (workflowTopic, namespace) => {
-            //namespace isolation requires the connection options to be hashed
-            //as multiple intersecting databases can be used by the same service
-            //hashing options allows for reuse of the same connection without risk of
-            //overwriting data in another namespace.
-            const optionsHash = this.hashOptions();
-            const targetNS = namespace ?? factory_1.APP_ID;
-            const connectionNS = `${optionsHash}.${targetNS}`;
-            if (ClientService.instances.has(connectionNS)) {
-                const hotMeshClient = await ClientService.instances.get(connectionNS);
-                await this.verifyWorkflowActive(hotMeshClient, targetNS);
-                return hotMeshClient;
-            }
-            //init, but don't await
-            const readonly = this.connection.readonly ?? undefined;
-            let hotMeshClient = hotmesh_1.HotMesh.init({
-                appId: targetNS,
-                logLevel: enums_1.HMSH_LOGLEVEL,
-                engine: {
-                    readonly,
-                    connection: this.connection,
-                },
-            });
-            //synchronously cache the promise (before awaiting)
-            ClientService.instances.set(connectionNS, hotMeshClient);
-            //resolve, activate, and return the client
-            const resolvedClient = await hotMeshClient;
-            if (!readonly) {
-                resolvedClient.engine.logger.info('meshflow-readonly-client', {
-                    guid: resolvedClient.engine.guid,
-                    appId: targetNS,
-                });
-                await this.activateWorkflow(resolvedClient, targetNS);
-            }
-            return resolvedClient;
-        };
-        /**
-         * It is possible for a client to invoke a workflow without first
-         * creating the stream. This method will verify that the stream
-         * exists and if not, create it.
-         * @private
-         */
-        this.verifyStream = async (hotMeshClient, workflowTopic, namespace) => {
-            const optionsHash = this.hashOptions();
-            const targetNS = namespace ?? factory_1.APP_ID;
-            const targetTopic = `${optionsHash}.${targetNS}.${workflowTopic}`;
-            if (!ClientService.topics.includes(targetTopic)) {
-                ClientService.topics.push(targetTopic);
-                await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
-            }
-        };
-        /**
-         * @private
-         */
-        this.search = async (hotMeshClient, index, query) => {
-            const searchClient = hotMeshClient.engine.search;
-            return await searchClient.sendIndexedQuery(index, query);
-        };
-        /**
-         * The MeshFlow `Client` service is functionally
-         * equivalent to the Temporal `Client` service.
-         * Starting a workflow is the primary use case and
-         * is accessed by calling workflow.start().
-         */
-        this.workflow = {
-            /**
-             * Starts a workflow, verifies the idempotent id, and
-             * adds searchable data to the record.
-             */
-            start: async (options) => {
-                const taskQueueName = options.taskQueue ?? options.entity;
-                const workflowName = options.entity ?? options.workflowName;
-                const trc = options.workflowTrace;
-                const spn = options.workflowSpan;
-                //hotmesh `topic` is equivalent to `queue+workflowname` pattern in other systems
-                const workflowTopic = `${taskQueueName}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
-                //verify that the stream channel exists before enqueueing
-                await this.verifyStream(hotMeshClient, workflowTopic, options.namespace);
-                const payload = {
-                    arguments: [...options.args],
-                    originJobId: options.originJobId,
-                    expire: options.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS,
-                    persistent: options.persistent,
-                    signalIn: options.signalIn,
-                    parentWorkflowId: options.parentWorkflowId,
-                    workflowId: options.workflowId || hotmesh_1.HotMesh.guid(),
-                    workflowTopic: workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
-                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
-                };
-                const context = { metadata: { trc, spn }, data: {} };
-                const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context, {
-                    search: options?.search?.data,
-                    marker: options?.marker,
-                    pending: options?.pending,
-                });
-                return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
-            },
-            /**
-             * Sends a message payload to a running workflow that is paused and awaiting the signal
-             */
-            signal: async (signalId, data, namespace) => {
-                const topic = `${namespace ?? factory_1.APP_ID}.wfs.signal`;
-                return await (await this.getHotMeshClient(topic, namespace)).hook(topic, { id: signalId, data });
-            },
-            /**
-             * Spawns an a new, isolated execution cycle within the same job.
-             * Similar to `worker` functions, `hook` functions have a linked
-             * function. But hooks do not start a new job and instead read/write
-             * their isolated activity data to an existing Job record (HASH).
-             *
-             * This example spawns a hook that will update workflow `guid123`.
-             *
-             * @example
-             * ```typescript
-             * await client.workflow.hook({
-             *   namespace: 'demo',
-             *   taskQueue: 'default',
-             *   workflowName: 'myDemoFunction',
-             *   workflowId: 'guid123',
-             *   args: ['Hello'],
-             * });
-             * ```
-             */
-            hook: async (options) => {
-                const workflowTopic = `${options.taskQueue ?? options.entity}-${options.entity ?? options.workflowName}`;
-                const payload = {
-                    arguments: [...options.args],
-                    id: options.workflowId,
-                    workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
-                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
-                };
-                //seed search data before entering
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
-                const msgId = await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
-                //todo: commit search data BEFORE enqueuing hook
-                if (options.search?.data) {
-                    const searchSessionId = `-search-${hotmesh_1.HotMesh.guid()}-0`;
-                    const search = new search_1.Search(options.workflowId, hotMeshClient, searchSessionId);
-                    const entries = Object.entries(options.search.data).flat();
-                    await search.set(...entries);
-                }
-                return msgId;
-            },
-            /**
-             * Returns a reference to a running workflow,
-             * allowing callers to check the status of the workflow,
-             * interrupt it, and even await its eventual response
-             * if still in a pending state.
-             *
-             * @example
-             * ```typescript
-             * const handle = await client.workflow.getHandle(
-             *  'default',
-             *  'myFunction',
-             *  'someGuid123',
-             *  'demo',
-             * );
-             * ```
-             */
-            getHandle: async (taskQueue, workflowName, workflowId, namespace) => {
-                const workflowTopic = `${taskQueue}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
-                return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
-            },
-            /**
-             * Provides direct access to the SEARCH backend when making
-             * queries. Taskqueues and workflow names are
-             * used to identify the point of presence to use. `...args` is
-             * the tokenized query. When querying Redis/FTSEARCH, the trailing
-             * ...args might be `'@_custom1:meshflow'`. For postgres,
-             * the trailing ...args would be: `'_custom', 'meshflow'`. In each case,
-             * the query looks for all job data where the field `_custom` is
-             * equal to `meshflow`.
-             *
-             * @example
-             * ```typescript
-             * await client.workflow.search(
-             *   'someTaskQueue'
-             *   'someWorkflowName',
-             *   'meshflow',
-             *   'user',
-             *   ...args,
-             * );
-             * //returns [count, [id, fields[]], [id, fields[]], [id, fields[]], ...]]
-             * ```
-             */
-            search: async (taskQueue, workflowName, namespace, index, ...query) => {
-                const workflowTopic = `${taskQueue}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
-                try {
-                    return await this.search(hotMeshClient, index, query);
-                }
-                catch (error) {
-                    hotMeshClient.engine.logger.error('meshflow-client-search-err', {
-                        error,
-                    });
-                    throw error;
-                }
-            },
-        };
-        this.connection = config.connection;
-    }
-    hashOptions() {
-        if ('options' in this.connection) {
-            //shorthand format
-            return (0, utils_1.hashOptions)(this.connection.options);
-        }
-        else {
-            //longhand format (sub, store, stream, pub, search)
-            const response = [];
-            for (const p in this.connection) {
-                if (this.connection[p].options) {
-                    response.push((0, utils_1.hashOptions)(this.connection[p].options));
-                }
-            }
-            return response.join('');
-        }
-    }
-    /**
-     * Any router can be used to deploy and activate the HotMesh
-     * distributed executable to the active quorum EXCEPT for
-     * those routers in `readonly` mode.
-     */
-    async deployAndActivate(namespace = factory_1.APP_ID, version = factory_1.APP_VERSION) {
-        if (isNaN(Number(version))) {
-            throw new Error('Invalid version number');
-        }
-        const hotMesh = await this.getHotMeshClient('', namespace);
-        await this.activateWorkflow(hotMesh, namespace, version);
-    }
-    /**
-     * @private
-     */
-    async verifyWorkflowActive(hotMesh, appId = factory_1.APP_ID, count = 0) {
-        const app = await hotMesh.engine.store.getApp(appId);
-        const appVersion = app?.version;
-        if (isNaN(appVersion)) {
-            if (count > 10) {
-                throw new Error('Workflow failed to activate');
-            }
-            await (0, utils_1.sleepFor)(enums_1.HMSH_QUORUM_DELAY_MS * 2);
-            return await this.verifyWorkflowActive(hotMesh, appId, count + 1);
-        }
-        return true;
-    }
-    /**
-     * @private
-     */
-    async activateWorkflow(hotMesh, appId = factory_1.APP_ID, version = factory_1.APP_VERSION) {
-        const app = await hotMesh.engine.store.getApp(appId);
-        const appVersion = app?.version;
-        if (appVersion === version && !app.active) {
-            try {
-                await hotMesh.activate(version);
-            }
-            catch (error) {
-                hotMesh.engine.logger.error('meshflow-client-activate-err', {
-                    error,
-                });
-                throw error;
-            }
-        }
-        else if (isNaN(Number(appVersion)) || appVersion < version) {
-            try {
-                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(appId, version));
-                await hotMesh.activate(version);
-            }
-            catch (error) {
-                hotMesh.engine.logger.error('meshflow-client-deploy-activate-err', {
-                    error,
-                });
-                throw error;
-            }
-        }
-    }
-    /**
-     * @private
-     */
-    static async shutdown() {
-        for (const [_, hotMeshInstance] of ClientService.instances) {
-            (await hotMeshInstance).stop();
-        }
-    }
-}
-_a = ClientService;
-/**
- * @private
- */
-ClientService.topics = [];
-/**
- * @private
- */
-ClientService.instances = new Map();
-/**
- * Creates a stream where messages can be published to ensure there is a
- * channel in place when the message arrives (a race condition for those
- * platforms without implicit topic setup).
- * @private
- */
-ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) => {
-    const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
-    const streamKey = hotMeshClient.engine.store.mintKey(key_1.KeyType.STREAMS, params);
-    try {
-        await hotMeshClient.engine.stream.createConsumerGroup(streamKey, 'WORKER');
-    }
-    catch (err) {
-        //ignore if already exists
-    }
-};
-exports.ClientService = ClientService;

package/build/services/meshflow/connection.d.ts

@@ -1,23 +0,0 @@
-import { Connection } from '../../types/meshflow';
-import { ProviderConfig, ProvidersConfig } from '../../types/provider';
-/**
- * The Connection service is used to declare the class
- * and connection options but does not connect quite yet. Connection
- * happens at a later lifecycle stage when a workflow
- * is started by the MeshFlow Client module (`(new MeshFlow.Client())).start()`).
- *
- * The config options optionall support a multi-connection setup
- * where the `store` connection explicitly defined along with `stream`, `sub`, etc.
- * For example, Postgres can be used for stream and store while
- * Redis is used for sub.
- */
-export declare class ConnectionService {
-    /**
-     * @private
-     */
-    constructor();
-    /**
-     * Instance initializer
-     */
-    static connect(config: ProviderConfig | ProvidersConfig): Promise<Connection>;
-}

package/build/services/meshflow/connection.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionService = void 0;
-/**
- * The Connection service is used to declare the class
- * and connection options but does not connect quite yet. Connection
- * happens at a later lifecycle stage when a workflow
- * is started by the MeshFlow Client module (`(new MeshFlow.Client())).start()`).
- *
- * The config options optionall support a multi-connection setup
- * where the `store` connection explicitly defined along with `stream`, `sub`, etc.
- * For example, Postgres can be used for stream and store while
- * Redis is used for sub.
- */
-class ConnectionService {
-    /**
-     * @private
-     */
-    constructor() { }
-    /**
-     * Instance initializer
-     */
-    static async connect(config) {
-        return 'store' in config
-            ? config
-            : {
-                class: config.class,
-                options: { ...config.options },
-                provider: config.provider,
-            };
-    }
-}
-exports.ConnectionService = ConnectionService;

package/build/services/meshflow/exporter.d.ts

@@ -1,51 +0,0 @@
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { ExportOptions, MeshFlowJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
-import { ProviderClient, ProviderTransaction } from '../../types/provider';
-import { StringStringType, Symbols } from '../../types/serializer';
-declare class ExporterService {
-    appId: string;
-    logger: ILogger;
-    store: StoreService<ProviderClient, ProviderTransaction>;
-    symbols: Promise<Symbols> | Symbols;
-    private static symbols;
-    constructor(appId: string, store: StoreService<ProviderClient, ProviderTransaction>, logger: ILogger);
-    /**
-     * Convert the job hash from its compiles format into a MeshFlowJobExport object with
-     * facets that describe the workflow in terms relevant to narrative storytelling.
-     */
-    export(jobId: string, options?: ExportOptions): Promise<MeshFlowJobExport>;
-    /**
-     * Inflates the job data from Redis into a MeshFlowJobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
-     */
-    inflate(jobHash: StringStringType, options: ExportOptions): MeshFlowJobExport;
-    resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null;
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     * @private
-     */
-    inflateKey(key: string): string;
-    filterFields(fullObject: MeshFlowJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<MeshFlowJobExport>;
-    inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>): void;
-    sortEntriesByCreated(obj: {
-        [key: string]: TransitionType;
-    }): TransitionType[];
-    /**
-     * marker names are overloaded with details like sequence, type, etc
-     */
-    keyToObject(key: string): {
-        index: number;
-        dimension?: string;
-        secondary?: number;
-    };
-    /**
-     * idem list has a complicated sort order based on indexes and dimensions
-     */
-    sortParts(parts: TimelineType[]): TimelineType[];
-}
-export { ExporterService };

package/build/services/meshflow/exporter.js

@@ -1 +0,0 @@
-'use strict';const y=b;function a(){const L=['getRaw','updated','9jzSDhP','get','SerializerService','join','localeCompare','6502856qmtcGQ','appId','/output/metadata/ac','entries','66894lHtLFd','__esModule','defineProperty','getAllSymbols','sort','../serializer','split','resolveValue','logger','inflateKey','match','7ovBXSX','store','shift','/output/metadata/au','keyToObject','sortParts','139932aJYKKN','inflate','385767pmciYU','sortEntriesByCreated','../../modules/utils','has','restoreHierarchy','substring','1933008bMdrHA','export','values','startsWith','push','created','inflateTransition','$error','length','ExporterService','endsWith','1992138tWVggU','data','forEach','590RrLYZT','symbols','set','filterFields','2346615cqidAr','fromString'];a=function(){return L;};return a();}(function(c,d){const x=b,e=c();while(!![]){try{const f=parseInt(x(0x170))/0x1*(parseInt(x(0x141))/0x2)+-parseInt(x(0x165))/0x3+-parseInt(x(0x152))/0x4+-parseInt(x(0x16c))/0x5+-parseInt(x(0x15a))/0x6+parseInt(x(0x14c))/0x7*(-parseInt(x(0x13d))/0x8)+-parseInt(x(0x154))/0x9*(-parseInt(x(0x168))/0xa);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x808e3));function b(c,d){const e=a();return b=function(f,g){f=f-0x13c;let h=e[f];return h;},b(c,d);}Object[y(0x143)](exports,y(0x142),{'value':!0x0}),exports[y(0x163)]=void 0x0;const utils_1=require(y(0x156)),serializer_1=require(y(0x146));class ExporterService{constructor(c,d,f){const z=y;this['appId']=c,this[z(0x149)]=f,this[z(0x14d)]=d;}async[y(0x15b)](c,d={}){const A=y;if(!ExporterService[A(0x169)][A(0x157)](this['appId'])){const g=this[A(0x14d)][A(0x144)]();ExporterService[A(0x169)][A(0x16a)](this[A(0x13e)],await g);}const f=await this['store'][A(0x16e)](c);return this[A(0x153)](f,d);}[y(0x153)](c,d){const B=y,f=[],g={},h={},j={},k=/^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;return Object[B(0x140)](c)[B(0x167)](([m,p])=>{const C=B,q=m[C(0x14b)](k);if(q)this[C(0x160)](q,p,j);else{if(m[C(0x15d)]('_'))h[m[C(0x159)](0x1)]=p;else{if(m[C(0x15d)]('-')){const u=this[C(0x150)](m);f[C(0x15e)]({...u,'key':m,'value':this[C(0x148)](p,d['values'])});}else 0x3===m[C(0x162)]&&(g[this[C(0x14a)](m)]=serializer_1[C(0x172)][C(0x16d)](p));}}}),this['filterFields']({'data':(0x0,utils_1[B(0x158)])(h),'state':Object[B(0x140)]((0x0,utils_1['restoreHierarchy'])(g))[0x0][0x1],'status':parseInt(c[':'],0xa),'timeline':this[B(0x151)](f),'transitions':this['sortEntriesByCreated'](j)},d['block'],d['allow']);}['resolveValue'](c,d){const D=y,f=serializer_1[D(0x172)][D(0x16d)](c);return!0x1!==d||f&&'object'==typeof f&&(D(0x166)in f&&(f[D(0x166)]={}),D(0x161)in f&&(f[D(0x161)]={})),f;}[y(0x14a)](c){const E=y,d=ExporterService['symbols'][E(0x171)](this[E(0x13e)]);if(c in d)return d[c]['split']('/')[E(0x173)]('/');return c;}[y(0x16b)](c,d=[],f=[]){const F=y;let g={};return f&&f[F(0x162)]>0x0?f[F(0x167)](h=>{h in c&&(g[h]=c[h]);}):g={...c},d&&d[F(0x162)]>0x0&&d['forEach'](h=>{h in g&&delete g[h];}),g;}[y(0x160)](c,f,g){const G=y,[h,j,k]=c,m=this['inflateKey'](j),p=m[G(0x147)]('/')[0x0],q=m[G(0x164)](G(0x13f)),u=m[G(0x164)](G(0x14f));if(q||u){const v=p+','+k,w=g[v];w?w[q?G(0x15f):G(0x16f)]=f:g[v]={'activity':p,'dimensions':k,'created':q?f:null,'updated':u?f:null};}}[y(0x155)](c){const H=y,d=Object[H(0x15c)](c);return d[H(0x145)]((f,g)=>(f[H(0x15f)]||f[H(0x16f)])[H(0x13c)](g[H(0x15f)]||g['updated'])),d;}[y(0x150)](c){const J=y;function d(g){const I=b,h=g[I(0x147)](',');if(h[I(0x162)]>0x1)return h[I(0x14e)](),h[I(0x173)](',');}const f=c['split']('-');return 0x4===f[J(0x162)]?{'index':parseInt(f[0x2],0xa),'dimension':d(f[0x1])}:{'index':parseInt(f[0x2],0xa),'secondary':parseInt(f[0x3],0xa),'dimension':d(f[0x1])};}[y(0x151)](c){const K=y;return c[K(0x145)]((d,f)=>{const {dimension:g,index:h,secondary:j}=d,{dimension:k,index:l,secondary:m}=f;if(void 0x0===g&&void 0x0!==k)return-0x1;if(void 0x0!==g&&void 0x0===k)return 0x1;if(void 0x0!==g&&void 0x0!==k){if(g<k)return-0x1;if(g>k)return 0x1;}if(h<l)return-0x1;if(h>l)return 0x1;if(void 0x0===j&&void 0x0!==m)return-0x1;if(void 0x0!==j&&void 0x0===m)return 0x1;if(void 0x0!==j&&void 0x0!==m){if(j<m)return-0x1;if(j>m)return 0x1;}return 0x0;});}}exports['ExporterService']=ExporterService,ExporterService[y(0x169)]=new Map();