@moostjs/event-wf 0.3.1 → 0.3.3

package/dist/index.mjs

@@ -1,7 +1,8 @@
-import { getMoostMate as getMoostMate$1, getMoostInfact, defineMoostEventHandler } from 'moost';
+import { getMoostMate, getMoostInfact, defineMoostEventHandler, Resolve } from 'moost';
 import { WooksWf, createWfApp, useWfState } from '@wooksjs/event-wf';
-import { useEventId, useEventContext } from '@wooksjs/event-core';
-import 'wooks';
+export { useWFContext } from '@wooksjs/event-wf';
+import { useEventId } from '@wooksjs/event-core';
+export { StepRetriableError } from '@prostojs/wf';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -31,7 +32,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
 }
 
 function getWfMate() {
-    return getMoostMate$1();
+    return getMoostMate();
 }
 
 const LOGGER_TITLE = 'moost-wf';
@@ -71,14 +72,14 @@ class MoostWf {
         this.moost = moost;
         this.toInit.forEach(fn => fn());
     }
-    start(schemaId, inputContext, input) {
-        return this.wfApp.start(schemaId, inputContext, input, () => {
+    start(schemaId, initialContext, input) {
+        return this.wfApp.start(schemaId, initialContext, input, () => { }, () => {
             const scopeId = useEventId().getId();
             getMoostInfact().unregisterScope(scopeId);
         });
     }
-    resume(schemaId, inputContext, indexes, input) {
-        return this.wfApp.resume(schemaId, inputContext, indexes, input, () => {
+    resume(schemaId, state, input) {
+        return this.wfApp.resume(schemaId, state, input, () => { }, () => {
             const scopeId = useEventId().getId();
             getMoostInfact().unregisterScope(scopeId);
         });
@@ -129,681 +130,6 @@ class MoostWf {
     }
 }
 
-function getConstructor$1(instance) {
-    return isConstructor(instance) ?
-        instance : instance.constructor ?
-        instance.constructor : Object.getPrototypeOf(instance).constructor;
-}
-function isConstructor(v) {
-    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
-}
-
-const classMetadata = {};
-const paramMetadata = {};
-const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
-function getMetaObject(target, prop) {
-    const isParam = typeof prop !== 'undefined';
-    const metadata = isParam ? paramMetadata : classMetadata;
-    const targetKey = Symbol.for(getConstructor$1(target));
-    let meta = metadata[targetKey] = metadata[targetKey] || {};
-    if (isParam)
-        meta = (meta[prop] = meta[prop] || {});
-    return meta;
-}
-const _reflect = {
-    getOwnMetadata(key, target, prop) {
-        return getMetaObject(target, prop)[key];
-    },
-    defineMetadata(key, data, target, prop) {
-        const meta = getMetaObject(target, prop);
-        meta[key] = data;
-    },
-    metadata(key, data) {
-        return ((target, propKey) => {
-            Reflect$1.defineMetadata(key, data, target, propKey);
-        });
-    },
-};
-if (!root.Reflect) {
-    root.Reflect = _reflect;
-}
-else {
-    const funcs = [
-        'getOwnMetadata',
-        'defineMetadata',
-        'metadata',
-    ];
-    const target = root.Reflect;
-    for (const func of funcs) {
-        if (typeof target[func] !== 'function') {
-            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
-        }
-    }
-}
-const Reflect$1 = _reflect;
-
-const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
-class Mate {
-    constructor(workspace, options = {}) {
-        this.workspace = workspace;
-        this.options = options;
-        this.logger = options.logger || console;
-    }
-    set(args, key, value, isArray) {
-        var _a;
-        let level = 'CLASS';
-        const newArgs = args.level === 'CLASS' ? { target: args.target }
-            : args.level === 'PROP' ? { target: args.target, propKey: args.propKey }
-                : args;
-        let meta = (Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
-        if (newArgs.propKey && this.options.readReturnType && !meta.returnType && args.descriptor) {
-            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
-        }
-        if (newArgs.propKey && this.options.readType && !meta.type) {
-            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
-        }
-        const { index } = newArgs;
-        const cb = typeof key === 'function' ? key : undefined;
-        let data = meta;
-        if (!data.params) {
-            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
-        }
-        if (typeof index === 'number') {
-            level = 'PARAM';
-            data.params = data.params || [];
-            data.params[index] = data.params[index] || {
-                type: undefined,
-            };
-            if (cb) {
-                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-            }
-            else {
-                data = data.params[index];
-            }
-        }
-        else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== 'CLASS') {
-            this.set({ ...args, level: 'CLASS' }, (meta) => {
-                if (!meta.properties) {
-                    meta.properties = [args.propKey];
-                }
-                else if (!meta.properties.includes(args.propKey)) {
-                    meta.properties.push(args.propKey);
-                }
-                return meta;
-            });
-        }
-        level = typeof index === 'number' ? 'PARAM' : newArgs.propKey && newArgs.descriptor ? 'METHOD' : newArgs.propKey ? 'PROP' : 'CLASS';
-        if (typeof key !== 'function') {
-            if (isArray) {
-                const newArray = (data[key] || []);
-                if (!Array.isArray(newArray)) {
-                    this.logger.error('Mate.add (isArray=true) called for non-array metadata');
-                }
-                newArray.unshift(value);
-                data[key] = newArray;
-            }
-            else {
-                data[key] = value;
-            }
-        }
-        else if (cb && typeof index !== 'number') {
-            meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-        }
-        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
-    }
-    read(target, propKey) {
-        const isConstr = isConstructor(target);
-        const constructor = isConstr ? target : getConstructor$1(target);
-        const proto = constructor.prototype;
-        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
-        if (this.options.inherit) {
-            const inheritFn = typeof this.options.inherit === 'function' ? this.options.inherit : undefined;
-            let shouldInherit = this.options.inherit;
-            if (inheritFn) {
-                if (typeof propKey === 'string') {
-                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
-                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
-                }
-                else {
-                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
-                }
-            }
-            if (shouldInherit) {
-                const parent = Object.getPrototypeOf(constructor);
-                if (typeof parent === 'function' && parent !== fnProto && parent !== constructor) {
-                    const inheritedMeta = (this.read(parent, propKey) || {});
-                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
-                    ownMeta = { ...inheritedMeta, ...ownMeta };
-                    if (typeof propKey === 'string' && ownParams && (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
-                        for (let i = 0; i < ownParams.length; i++) {
-                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !== 'undefined') {
-                                const ownParam = ownParams[i];
-                                if (ownMeta.params && inheritFn && inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string' ? propKey : undefined)) {
-                                    ownMeta.params[i] = {
-                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
-                                        ...ownParams[i],
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return ownMeta;
-    }
-    apply(...decorators) {
-        return ((target, propKey, descriptor) => {
-            for (const d of decorators) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorate(key, value, isArray, level) {
-        return ((target, propKey, descriptor) => {
-            const args = {
-                target,
-                propKey,
-                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
-                index: typeof descriptor === 'number' ? descriptor : undefined,
-                level,
-            };
-            this.set(args, key, value, isArray);
-        });
-    }
-    decorateConditional(ccb) {
-        return ((target, propKey, descriptor) => {
-            const hasIndex = typeof descriptor === 'number';
-            const decoratorLevel = hasIndex ? 'PARAM' : propKey && descriptor ? 'METHOD' : propKey ? 'PROP' : 'CLASS';
-            const d = ccb(decoratorLevel);
-            if (d) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorateClass(key, value, isArray) {
-        return this.decorate(key, value, isArray, 'CLASS');
-    }
-}
-const fnProto = Object.getPrototypeOf(Function);
-
-const METADATA_WORKSPACE = 'moost';
-const moostMate = new Mate(METADATA_WORKSPACE, {
-    readType: true,
-    readReturnType: true,
-    collectPropKeys: true,
-    inherit(classMeta, targetMeta, level) {
-        if (level === 'CLASS') {
-            return !!(classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit);
-        }
-        if (level === 'PROP') {
-            return (!!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit) || !!((classMeta === null || classMeta === void 0 ? void 0 : classMeta.inherit) && !targetMeta));
-        }
-        return !!(targetMeta === null || targetMeta === void 0 ? void 0 : targetMeta.inherit);
-    },
-});
-function getMoostMate() {
-    return moostMate;
-}
-
-function getConstructor(instance) {
-    return Object.getPrototypeOf(instance).constructor;
-}
-
-const globalRegistry = {};
-const UNDEFINED = Symbol('undefined');
-class Infact {
-    constructor(options) {
-        this.options = options;
-        this.registry = {};
-        this.provideRegByInstance = new WeakMap();
-        this.scopes = {};
-        this._silent = false;
-        this.logger = options.logger || console;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    silent(value = 'logs') {
-        this._silent = value;
-    }
-    registerScope(scopeId) {
-        if (!this.scopes[scopeId]) {
-            this.scopes[scopeId] = {};
-        }
-    }
-    unregisterScope(scopeId) {
-        delete this.scopes[scopeId];
-    }
-    getForInstance(instance, classConstructor, opts) {
-        return this.get(classConstructor, { ...opts, provide: this.getProvideRegByInstnce(instance) || {} });
-    }
-    async get(classConstructor, opts, optional = false) {
-        const result = await this._get(classConstructor, opts, optional);
-        if (result) {
-            const { instance, mergedProvide } = result;
-            if (this.options.storeProvideRegByInstance) {
-                this.setProvideRegByInstance(instance, mergedProvide);
-            }
-            return instance;
-        }
-        return undefined;
-    }
-    setProvideRegByInstance(instance, provide) {
-        this.provideRegByInstance.set(instance, provide);
-    }
-    getProvideRegByInstnce(instance) {
-        return this.provideRegByInstance.get(instance) || {};
-    }
-    async _get(classConstructor, opts, optional) {
-        const hierarchy = (opts === null || opts === void 0 ? void 0 : opts.hierarchy) || [];
-        const provide = opts === null || opts === void 0 ? void 0 : opts.provide;
-        const syncContextFn = opts === null || opts === void 0 ? void 0 : opts.syncContextFn;
-        hierarchy.push(classConstructor.name);
-        let classMeta;
-        try {
-            classMeta = this.options.describeClass(classConstructor);
-        }
-        catch (e) {
-            throw this.panicOwnError(`Could not instantiate "${classConstructor.name}". `
-                + `An error occored on "describeClass" function.\n${e.message}`, hierarchy);
-        }
-        const instanceKey = Symbol.for(classConstructor);
-        if (!classMeta || !classMeta.injectable) {
-            if (provide && provide[instanceKey]) {
-                syncContextFn && syncContextFn(classMeta);
-                return { instance: await getProvidedValue(provide[instanceKey]), mergedProvide: provide };
-            }
-            if (!optional) {
-                throw this.panicOwnError(`Could not instantiate Injectable "${classConstructor.name}". `
-                    + 'Please check if the class is injectable or if you properly typed arguments.', hierarchy);
-            }
-            else {
-                return undefined;
-            }
-        }
-        if (classMeta.scopeId && classMeta.global) {
-            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". `
-                + 'The scoped Injectable is not supported for Global scope.', hierarchy);
-        }
-        if (classMeta.scopeId && !this.scopes[classMeta.scopeId]) {
-            throw this.panicOwnError(`Could not instantiate scoped Injectable "${classConstructor.name}" for scope "${classMeta.scopeId}". `
-                + 'The requested scope isn\'t registered.', hierarchy);
-        }
-        const scope = classMeta.scopeId ? this.scopes[classMeta.scopeId] : {};
-        const mergedProvide = { ...(provide || {}), ...(classMeta.provide || {}) };
-        if (mergedProvide[instanceKey]) {
-            syncContextFn && syncContextFn(classMeta);
-            return { instance: await getProvidedValue(mergedProvide[instanceKey]), mergedProvide };
-        }
-        if (!this.registry[instanceKey] && !globalRegistry[instanceKey] && !scope[instanceKey]) {
-            const registry = classMeta.scopeId ? scope : classMeta.global ? globalRegistry : this.registry;
-            const params = classMeta.constructorParams || [];
-            const isCircular = !!params.find(p => !!p.circular);
-            if (isCircular) {
-                registry[instanceKey] = Object.create(classConstructor.prototype);
-            }
-            const resolvedParams = [];
-            for (let i = 0; i < params.length; i++) {
-                const param = params[i];
-                if (param.inject) {
-                    if (mergedProvide && mergedProvide[param.inject]) {
-                        resolvedParams[i] = getProvidedValue(mergedProvide[param.inject]);
-                    }
-                    else if (param.nullable || param.optional) {
-                        resolvedParams[i] = UNDEFINED;
-                    }
-                    else {
-                        throw this.panicOwnError(`Could not inject ${JSON.stringify(param.inject)} to "${classConstructor.name}" to argument ${param.label ? `labeled as "${param.label}"` : `with index ${i}`}`, hierarchy);
-                    }
-                }
-                else if (this.options.resolveParam) {
-                    resolvedParams[i] = this.options.resolveParam({
-                        classMeta,
-                        classConstructor,
-                        index: i,
-                        paramMeta: param,
-                        customData: opts === null || opts === void 0 ? void 0 : opts.customData,
-                    });
-                }
-            }
-            for (let i = 0; i < resolvedParams.length; i++) {
-                const rp = resolvedParams[i];
-                if (rp && rp !== UNDEFINED && typeof rp.then === 'function') {
-                    try {
-                        syncContextFn && syncContextFn(classMeta);
-                        resolvedParams[i] = await rp;
-                    }
-                    catch (e) {
-                        const param = params[i];
-                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" `
-                            + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
-                    }
-                }
-            }
-            for (let i = 0; i < params.length; i++) {
-                const param = params[i];
-                if (typeof resolvedParams[i] === 'undefined') {
-                    if (param.type === undefined && !param.circular) {
-                        if (this._silent === false) {
-                            this.logger.warn(`${classConstructor.name}.constructor() expects argument ${param.label ? `labeled as "${param.label}"` : `#${i}`} that is undefined. This might happen when Circular Dependency occurs. To handle Circular Dependencies please specify circular meta for param.`);
-                        }
-                    }
-                    else if (param.type === undefined && param.circular) {
-                        param.type = param.circular();
-                    }
-                    if (typeof param.type === 'function') {
-                        if ([String, Number, Date, Array].includes(param.type)) {
-                            if (!param.nullable && !param.optional) {
-                                throw this.panicOwnError(`Could not inject "${param.type.name}" to "${classConstructor.name}" `
-                                    + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. The param was not resolved to a value.`, hierarchy);
-                            }
-                        }
-                        resolvedParams[i] = this.get(param.type, { provide: mergedProvide, hierarchy, syncContextFn, customData: opts === null || opts === void 0 ? void 0 : opts.customData }, param.optional || param.nullable);
-                    }
-                }
-                if (resolvedParams[i] === UNDEFINED) {
-                    resolvedParams[i] = undefined;
-                }
-            }
-            for (let i = 0; i < resolvedParams.length; i++) {
-                const rp = resolvedParams[i];
-                if (rp && typeof rp.then === 'function') {
-                    try {
-                        syncContextFn && syncContextFn(classMeta);
-                        resolvedParams[i] = await rp;
-                    }
-                    catch (e) {
-                        const param = params[i];
-                        throw this.panic(e, `Could not inject "${param.type.name}" to "${classConstructor.name}" `
-                            + `constructor at index ${i}${param.label ? ` (${param.label})` : ''}. An exception occured.`, hierarchy);
-                    }
-                }
-            }
-            const instance = new classConstructor(...resolvedParams);
-            if (isCircular) {
-                Object.assign(registry[instanceKey], instance);
-            }
-            else {
-                registry[instanceKey] = instance;
-            }
-            if (this.options.describeProp && this.options.resolveProp && classMeta.properties && classMeta.properties.length) {
-                const resolvedProps = {};
-                for (const prop of classMeta.properties) {
-                    const initialValue = instance[prop];
-                    let propMeta;
-                    try {
-                        propMeta = this.options.describeProp(classConstructor, prop);
-                    }
-                    catch (e) {
-                        throw this.panic(e, `Could not process prop "${prop}" of "${classConstructor.name}". `
-                            + `An error occored on "describeProp" function.\n${e.message}`, hierarchy);
-                    }
-                    if (propMeta) {
-                        try {
-                            resolvedProps[prop] = this.options.resolveProp({
-                                classMeta,
-                                classConstructor,
-                                initialValue,
-                                key: prop,
-                                instance,
-                                propMeta,
-                                customData: opts === null || opts === void 0 ? void 0 : opts.customData,
-                            });
-                        }
-                        catch (e) {
-                            throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". `
-                                + 'An exception occured: ' + e.message, hierarchy);
-                        }
-                    }
-                }
-                for (const [prop, value] of Object.entries(resolvedProps)) {
-                    try {
-                        syncContextFn && syncContextFn(classMeta);
-                        resolvedProps[prop] = value ? await value : value;
-                    }
-                    catch (e) {
-                        throw this.panic(e, `Could not inject prop "${prop}" to "${classConstructor.name}". `
-                            + 'An exception occured: ' + e.message, hierarchy);
-                    }
-                }
-                Object.assign(instance, resolvedProps);
-            }
-            if (this._silent === false) {
-                this.logger.info(`Class "${'' + classConstructor.name + '' + ''}" instantiated with: ${''}[${resolvedParams.map(p => {
-                    switch (typeof p) {
-                        case 'number':
-                        case 'boolean':
-                            return p;
-                        case 'string':
-                            return `"${''}...${''}"`;
-                        case 'object':
-                            if (getConstructor(p))
-                                return getConstructor(p).name;
-                            return '{}';
-                        default: return '*';
-                    }
-                }).join(', ')}]`);
-            }
-        }
-        hierarchy.pop();
-        syncContextFn && syncContextFn(classMeta);
-        return { instance: await (scope[instanceKey] || this.registry[instanceKey] || globalRegistry[instanceKey]), mergedProvide };
-    }
-    panic(origError, text, hierarchy) {
-        if (this._silent === true) ;
-        else {
-            this.logger.error(text + (hierarchy ? ('\nHierarchy:\n' + hierarchy.join(' -> ')) : ''));
-        }
-        return origError;
-    }
-    panicOwnError(text, hierarchy) {
-        const e = new Error(text + (hierarchy ? ('\nHierarchy:\n' + hierarchy.join(' -> ')) : ''));
-        if (this._silent === true) {
-            return e;
-        }
-        else {
-            this.logger.error(e);
-            return e;
-        }
-    }
-}
-function getProvidedValue(meta) {
-    if (!meta.resolved) {
-        meta.resolved = true;
-        meta.value = meta.fn();
-    }
-    return meta.value;
-}
-
-function runPipes(pipes, initialValue, metas, level, restoreCtx) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let v = initialValue;
-        for (const pipe of pipes) {
-            restoreCtx && restoreCtx();
-            v = yield pipe.handler(v, metas, level);
-        }
-        return v;
-    });
-}
-
-getNewMoostInfact();
-function getNewMoostInfact() {
-    return new Infact({
-        describeClass(classConstructor) {
-            const meta = getMoostMate().read(classConstructor);
-            const infactMeta = {
-                injectable: !!(meta === null || meta === void 0 ? void 0 : meta.injectable),
-                global: false,
-                constructorParams: (meta === null || meta === void 0 ? void 0 : meta.params) || [],
-                provide: meta === null || meta === void 0 ? void 0 : meta.provide,
-                properties: (meta === null || meta === void 0 ? void 0 : meta.properties) || [],
-                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT'
-                    ? useEventId().getId()
-                    : undefined,
-            };
-            return infactMeta;
-        },
-        resolveParam({ paramMeta, classMeta, customData, classConstructor, index }) {
-            if (paramMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, undefined, {
-                    paramMeta,
-                    type: classConstructor,
-                    key: 'constructor',
-                    classMeta: classMeta,
-                    index,
-                    targetMeta: paramMeta,
-                }, 'PARAM');
-            }
-        },
-        describeProp(classConstructor, key) {
-            const meta = getMoostMate().read(classConstructor, key);
-            return meta;
-        },
-        resolveProp({ instance, key, initialValue, propMeta, classMeta, customData, classConstructor, }) {
-            if (propMeta && customData && customData.pipes) {
-                return runPipes(customData.pipes, initialValue, {
-                    instance,
-                    type: classConstructor,
-                    key,
-                    propMeta,
-                    targetMeta: propMeta,
-                    classMeta: classMeta,
-                }, 'PROP');
-            }
-        },
-        storeProvideRegByInstance: true,
-    });
-}
-
-/**
- * ## Label
- * ### @Decorator
- * _Common purpose decorator that may be used by various adapters for various purposes_
- *
- * Stores Label metadata
- */
-function Label(value) {
-    return getMoostMate().decorate('label', value);
-}
-
-/**
- * Hook to the Response Status
- * @decorator
- * @param resolver - resolver function
- * @param label - field label
- * @paramType unknown
- */
-function Resolve(resolver, label) {
-    return (target, key, index) => {
-        const i = typeof index === 'number' ? index : undefined;
-        getMoostMate().decorate('resolver', (metas, level) => {
-            let newLabel = label;
-            if (!newLabel && level === 'PROP' && typeof metas.key === 'string') {
-                newLabel = metas.key;
-            }
-            fillLabel(target, key || '', i, newLabel);
-            return resolver(metas, level);
-        })(target, key, i);
-    };
-}
-function fillLabel(target, key, index, name) {
-    if (name) {
-        const meta = getMoostMate().read(target, key);
-        if (typeof index === 'number') {
-            if (!(meta === null || meta === void 0 ? void 0 : meta.params) ||
-                !(meta === null || meta === void 0 ? void 0 : meta.params[index]) ||
-                !(meta === null || meta === void 0 ? void 0 : meta.params[index].label)) {
-                Label(name)(target, key, index);
-            }
-        }
-        else {
-            if (!(meta === null || meta === void 0 ? void 0 : meta.label)) {
-                Label(name)(target, key);
-            }
-        }
-    }
-}
-
-getMoostMate().decorate((meta) => {
-    if (!meta.injectable)
-        meta.injectable = true;
-    return meta;
-});
-
-var TInterceptorPriority;
-(function (TInterceptorPriority) {
-    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
-    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
-    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
-    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
-    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
-    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
-    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
-})(TInterceptorPriority || (TInterceptorPriority = {}));
-
-var TPipePriority;
-(function (TPipePriority) {
-    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
-    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
-    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
-    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
-    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
-    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
-    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
-    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
-    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
-})(TPipePriority || (TPipePriority = {}));
-
-/**
- * ### Define Pipe Function
- *
- * ```ts
- * // example of a transform pipe
- * const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
- *         return typeof value === 'string' ? value.toUpperCase() : value
- *     },
- *     TPipePriority.TRANSFORM,
- * )
- * ```
- *
- * @param fn interceptor function
- * @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
- * @returns
- */
-function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
-    fn.priority = priority;
-    return fn;
-}
-
-const resolvePipe = definePipeFn((_value, metas, level) => {
-    var _a;
-    const resolver = (_a = metas.targetMeta) === null || _a === void 0 ? void 0 : _a.resolver;
-    if (resolver) {
-        return resolver(metas, level);
-    }
-    return undefined;
-}, TPipePriority.RESOLVE);
-
-[
-    {
-        handler: resolvePipe,
-        priority: TPipePriority.RESOLVE,
-    },
-];
-
-const defaultLevels = [
-    'fatal',
-    'error',
-    'warn',
-    'log',
-    'info',
-    'debug',
-    'trace',
-];
-const defaultMappedLevels = new Map();
-defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
-
 function WStep(path) {
     return getWfMate().decorate('handlers', { path, type: 'WF_STEP' }, true);
 }
@@ -822,16 +148,7 @@ const WfIndexes = () => Resolve(() => useWfState().indexes);
 const WfSchemaId = () => Resolve(() => useWfState().schemaId);
 const WfInput = (name) => Resolve(() => {
     const i = useWfState().input();
-    return name ? i[name] : i;
+    return typeof i !== 'undefined' ? (name ? i[name] : i) : undefined;
 }, name || 'WfInput');
 
-/**
- * Wrapper on top of useEventContext that provides
- * proper context types for CLI event
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-function useCliContext() {
-    return useEventContext('CLI');
-}
-
-export { MoostWf, WFlow, WSchema, WStep, WfCtx, WfIndexes, WfInput, WfResume, WfSchemaId, useCliContext };
+export { MoostWf, WFlow, WSchema, WStep, WfCtx, WfIndexes, WfInput, WfResume, WfSchemaId };