@backtest-kit/pinets 3.4.0 → 3.5.0

package/build/index.cjs

@@ -102,6 +102,7 @@ const cacheServices$1 = {
 };
 const connectionServices$1 = {
     pineConnectionService: Symbol("pineConnectionService"),
+    indicatorConnectionService: Symbol("indicatorConnectionService"),
 };
 const markdownServices$1 = {
     pineMarkdownService: Symbol("pineMarkdownService"),
@@ -328,7 +329,8 @@ class PineJobService {
         this.axisProviderService = inject(TYPES.axisProviderService);
         this.candleProviderService = inject(TYPES.candleProviderService);
         this.pineConnectionService = inject(TYPES.pineConnectionService);
-        this.run = async (code, tickerId, timeframe = "1m", limit = 100) => {
+        this.indicatorConnectionService = inject(TYPES.indicatorConnectionService);
+        this.run = async (code, tickerId, timeframe = "1m", limit = 100, inputs = {}) => {
             this.loggerService.log("pineJobService run", {
                 script: code.source,
                 tickerId,
@@ -336,7 +338,18 @@ class PineJobService {
                 limit,
             });
             const runner = await CREATE_RUNNER_FN(this, tickerId, timeframe, limit);
-            return await runner.run(code.source);
+            const indicator = await this.indicatorConnectionService.getInstance(code.source, inputs);
+            const result = await runner.run(Object.keys(inputs).length ? indicator : code.source);
+            const plots = Object.entries(result.plots).reduce((acm, [key, value]) => {
+                if (key === "undefined") {
+                    return acm;
+                }
+                return {
+                    ...acm,
+                    [key]: value,
+                };
+            }, {});
+            return { plots };
         };
     }
 }
@@ -404,11 +417,11 @@ class PineCacheService {
     }
 }
 
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 const REQUIRE_PINE_FACTORY = () => {
     try {
         // @ts-ignore
-        const { PineTS } = require$1("pinets");
+        const { PineTS } = require$2("pinets");
         // @ts-ignore
         return PineTS;
     }
@@ -448,7 +461,7 @@ class PineConnectionService {
                 this.PineFactory = await LOAD_PINE_FACTORY_FN();
             }
             if (!this.PineFactory) {
-                throw new Error("PineTS import failed. Call usePine to provide a PineTS class to @backtest-kit/pinets.");
+                throw new Error("PineTS import failed (usePine). Call usePine to provide a PineTS class to @backtest-kit/pinets.");
             }
             return Reflect.construct(this.PineFactory, args);
         };
@@ -575,6 +588,68 @@ class PineMarkdownService {
     }
 }
 
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const REQUIRE_INDICATOR_FACTORY = () => {
+    try {
+        // @ts-ignore
+        const { Indicator } = require$1("pinets");
+        // @ts-ignore
+        return Indicator;
+    }
+    catch {
+        return null;
+    }
+};
+const IMPORT_INDICATOR_FACTORY = async () => {
+    try {
+        // @ts-ignore
+        const { Indicator } = await import('pinets');
+        // @ts-ignore
+        return Indicator;
+    }
+    catch {
+        return null;
+    }
+};
+const LOAD_INDICATOR_FACTORY_FN = functoolsKit.singleshot(async () => {
+    let ctor = null;
+    if (ctor = REQUIRE_INDICATOR_FACTORY()) {
+        return ctor;
+    }
+    if (ctor = await IMPORT_INDICATOR_FACTORY()) {
+        return ctor;
+    }
+    throw new Error("PineTS import failed (useIndicator). Call useIndicator to provide a PineTS class to @backtest-kit/pinets.");
+});
+class IndicatorConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getInstance = async (...args) => {
+            this.loggerService.log("indicatorConnectionService getInstance", {
+                args,
+            });
+            if (!this.IndicatorFactory) {
+                this.IndicatorFactory = await LOAD_INDICATOR_FACTORY_FN();
+            }
+            if (!this.IndicatorFactory) {
+                throw new Error("PineTS import failed. Call useIndicator to provide a PineTS class to @backtest-kit/pinets.");
+            }
+            return Reflect.construct(this.IndicatorFactory, args);
+        };
+        this.useIndicator = (ctor) => {
+            this.loggerService.log("indicatorConnectionService useIndicator", {
+                ctor,
+            });
+            this.IndicatorFactory = ctor;
+        };
+        this.clear = () => {
+            this.loggerService.log("indicatorConnectionService clear");
+            LOAD_INDICATOR_FACTORY_FN.clear();
+            this.IndicatorFactory = null;
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -596,6 +671,7 @@ class PineMarkdownService {
 }
 {
     provide(TYPES.pineConnectionService, () => new PineConnectionService());
+    provide(TYPES.indicatorConnectionService, () => new IndicatorConnectionService());
 }
 {
     provide(TYPES.pineMarkdownService, () => new PineMarkdownService());
@@ -622,6 +698,7 @@ const cacheServices = {
 };
 const connectionServices = {
     pineConnectionService: inject(TYPES.pineConnectionService),
+    indicatorConnectionService: inject(TYPES.indicatorConnectionService),
 };
 const markdownServices = {
     pineMarkdownService: inject(TYPES.pineMarkdownService),
@@ -638,14 +715,22 @@ const pine = {
 };
 init();
 
-const METHOD_NAME_USE_PINE = "pine.usePine";
+const METHOD_NAME_USE_PINE$1 = "pine.usePine";
 function usePine(ctor) {
-    pine.loggerService.log(METHOD_NAME_USE_PINE, {
+    pine.loggerService.log(METHOD_NAME_USE_PINE$1, {
         ctor,
     });
     pine.pineConnectionService.usePine(ctor);
 }
 
+const METHOD_NAME_USE_PINE = "indicator.useIndicator";
+function useIndicator(ctor) {
+    pine.loggerService.log(METHOD_NAME_USE_PINE, {
+        ctor,
+    });
+    pine.indicatorConnectionService.useIndicator(ctor);
+}
+
 const METHOD_NAME_RUN$2 = "run.run";
 const GET_SOURCE_FN$2 = async (source) => {
     if (File.isFile(source)) {
@@ -657,14 +742,14 @@ const GET_SOURCE_FN$2 = async (source) => {
     }
     throw new Error("Source must be a File or Code instance");
 };
-const BASE_RUNNER_FN$1 = async (script, symbol, timeframe, limit) => await pine.pineJobService.run(script, symbol, timeframe, limit);
+const BASE_RUNNER_FN$1 = async (script, symbol, timeframe, limit, inputs) => await pine.pineJobService.run(script, symbol, timeframe, limit, inputs);
 const VALIDATE_NO_TRADING_FN$1 = () => {
     if (backtestKit.ExecutionContextService.hasContext()) {
         throw new Error(functoolsKit.str.newline("Time overrides are not allowed when running scripts in a trading context.", "Please remove the 'when' parameter from the run function call."));
     }
 };
-const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, exchangeName, when) => {
-    let fn = () => BASE_RUNNER_FN$1(script, symbol, timeframe, limit);
+const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
+    let fn = () => BASE_RUNNER_FN$1(script, symbol, timeframe, limit, inputs);
     if (exchangeName) {
         fn = ExchangeContextService.runWithContext(fn, { exchangeName });
     }
@@ -677,14 +762,14 @@ const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, exchangeName, w
     }
     return fn;
 };
-const RUN_INFERENCE_FN$1 = async (script, symbol, timeframe, limit, exchangeName, when) => {
+const RUN_INFERENCE_FN$1 = async (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
     if (when) {
         VALIDATE_NO_TRADING_FN$1();
     }
-    const inference = CREATE_INFERENCE_FN$1(script, symbol, timeframe, limit, exchangeName, when);
+    const inference = CREATE_INFERENCE_FN$1(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return await inference();
 };
-async function run(source, { symbol, timeframe, limit }, exchangeName, when) {
+async function run(source, { symbol, timeframe, limit, inputs = {} }, exchangeName, when) {
     pine.loggerService.info(METHOD_NAME_RUN$2, {
         source,
         symbol,
@@ -692,7 +777,7 @@ async function run(source, { symbol, timeframe, limit }, exchangeName, when) {
         limit,
     });
     const script = await GET_SOURCE_FN$2(source);
-    const { plots } = await RUN_INFERENCE_FN$1(script, symbol, timeframe, limit, exchangeName, when);
+    const { plots } = await RUN_INFERENCE_FN$1(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return plots;
 }
 
@@ -760,14 +845,14 @@ const SIGNAL_SCHEMA = {
         transform: (v) => v || DEFAULT_ESTIMATED_TIME,
     },
 };
-async function getSignal(source, { symbol, timeframe, limit }) {
+async function getSignal(source, { symbol, timeframe, limit, inputs = {} }) {
     pine.loggerService.info(METHOD_NAME_RUN, {
         source,
         symbol,
         timeframe,
         limit,
     });
-    const { plots } = await pine.pineJobService.run(await GET_SOURCE_FN$1(source), symbol, timeframe, limit);
+    const { plots } = await pine.pineJobService.run(await GET_SOURCE_FN$1(source), symbol, timeframe, limit, inputs);
     const resultId = functoolsKit.randomString();
     const data = pine.pineDataService.extract(plots, SIGNAL_SCHEMA);
     return toSignalDto(resultId, data);
@@ -796,14 +881,14 @@ const GET_SOURCE_FN = async (source) => {
     }
     throw new Error("Source must be a File or Code instance");
 };
-const BASE_RUNNER_FN = async (script, symbol, timeframe, limit) => await pine.pineJobService.run(script, symbol, timeframe, limit);
+const BASE_RUNNER_FN = async (script, symbol, timeframe, limit, inputs) => await pine.pineJobService.run(script, symbol, timeframe, limit, inputs);
 const VALIDATE_NO_TRADING_FN = () => {
     if (backtestKit.ExecutionContextService.hasContext()) {
         throw new Error(functoolsKit.str.newline("Time overrides are not allowed when running scripts in a trading context.", "Please remove the 'when' parameter from the run function call."));
     }
 };
-const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, exchangeName, when) => {
-    let fn = () => BASE_RUNNER_FN(script, symbol, timeframe, limit);
+const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
+    let fn = () => BASE_RUNNER_FN(script, symbol, timeframe, limit, inputs);
     if (exchangeName) {
         fn = ExchangeContextService.runWithContext(fn, { exchangeName });
     }
@@ -816,11 +901,11 @@ const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, exchangeName, whe
     }
     return fn;
 };
-const RUN_INFERENCE_FN = async (script, symbol, timeframe, limit, exchangeName, when) => {
+const RUN_INFERENCE_FN = async (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
     if (when) {
         VALIDATE_NO_TRADING_FN();
     }
-    const inference = CREATE_INFERENCE_FN(script, symbol, timeframe, limit, exchangeName, when);
+    const inference = CREATE_INFERENCE_FN(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return await inference();
 };
 async function toMarkdown(signalId, plots, mapping, limit = Number.POSITIVE_INFINITY) {
@@ -832,7 +917,7 @@ async function toMarkdown(signalId, plots, mapping, limit = Number.POSITIVE_INFI
     });
     return await pine.pineMarkdownService.getReport(signalId, plots, mapping, limit);
 }
-async function markdown(signalId, source, { symbol, timeframe, limit }, mapping, exchangeName, when) {
+async function markdown(signalId, source, { symbol, timeframe, limit, inputs = {} }, mapping, exchangeName, when) {
     pine.loggerService.log(MARKDOWN_METHOD_NAME, {
         signalId,
         mapping,
@@ -840,7 +925,7 @@ async function markdown(signalId, source, { symbol, timeframe, limit }, mapping,
         exchangeName,
         when,
     });
-    const { plots } = await RUN_INFERENCE_FN(await GET_SOURCE_FN(source), symbol, timeframe, limit, exchangeName, when);
+    const { plots } = await RUN_INFERENCE_FN(await GET_SOURCE_FN(source), symbol, timeframe, limit, inputs, exchangeName, when);
     return await pine.pineMarkdownService.getReport(signalId, plots, mapping, Number.POSITIVE_INFINITY);
 }
 
@@ -856,4 +941,5 @@ exports.run = run;
 exports.setLogger = setLogger;
 exports.toMarkdown = toMarkdown;
 exports.toSignalDto = toSignalDto;
+exports.useIndicator = useIndicator;
 exports.usePine = usePine;

package/build/index.mjs

@@ -99,6 +99,7 @@ const cacheServices$1 = {
 };
 const connectionServices$1 = {
     pineConnectionService: Symbol("pineConnectionService"),
+    indicatorConnectionService: Symbol("indicatorConnectionService"),
 };
 const markdownServices$1 = {
     pineMarkdownService: Symbol("pineMarkdownService"),
@@ -325,7 +326,8 @@ class PineJobService {
         this.axisProviderService = inject(TYPES.axisProviderService);
         this.candleProviderService = inject(TYPES.candleProviderService);
         this.pineConnectionService = inject(TYPES.pineConnectionService);
-        this.run = async (code, tickerId, timeframe = "1m", limit = 100) => {
+        this.indicatorConnectionService = inject(TYPES.indicatorConnectionService);
+        this.run = async (code, tickerId, timeframe = "1m", limit = 100, inputs = {}) => {
             this.loggerService.log("pineJobService run", {
                 script: code.source,
                 tickerId,
@@ -333,7 +335,18 @@ class PineJobService {
                 limit,
             });
             const runner = await CREATE_RUNNER_FN(this, tickerId, timeframe, limit);
-            return await runner.run(code.source);
+            const indicator = await this.indicatorConnectionService.getInstance(code.source, inputs);
+            const result = await runner.run(Object.keys(inputs).length ? indicator : code.source);
+            const plots = Object.entries(result.plots).reduce((acm, [key, value]) => {
+                if (key === "undefined") {
+                    return acm;
+                }
+                return {
+                    ...acm,
+                    [key]: value,
+                };
+            }, {});
+            return { plots };
         };
     }
 }
@@ -401,11 +414,11 @@ class PineCacheService {
     }
 }
 
-const require = createRequire(import.meta.url);
+const require$1 = createRequire(import.meta.url);
 const REQUIRE_PINE_FACTORY = () => {
     try {
         // @ts-ignore
-        const { PineTS } = require("pinets");
+        const { PineTS } = require$1("pinets");
         // @ts-ignore
         return PineTS;
     }
@@ -445,7 +458,7 @@ class PineConnectionService {
                 this.PineFactory = await LOAD_PINE_FACTORY_FN();
             }
             if (!this.PineFactory) {
-                throw new Error("PineTS import failed. Call usePine to provide a PineTS class to @backtest-kit/pinets.");
+                throw new Error("PineTS import failed (usePine). Call usePine to provide a PineTS class to @backtest-kit/pinets.");
             }
             return Reflect.construct(this.PineFactory, args);
         };
@@ -572,6 +585,68 @@ class PineMarkdownService {
     }
 }
 
+const require = createRequire(import.meta.url);
+const REQUIRE_INDICATOR_FACTORY = () => {
+    try {
+        // @ts-ignore
+        const { Indicator } = require("pinets");
+        // @ts-ignore
+        return Indicator;
+    }
+    catch {
+        return null;
+    }
+};
+const IMPORT_INDICATOR_FACTORY = async () => {
+    try {
+        // @ts-ignore
+        const { Indicator } = await import('pinets');
+        // @ts-ignore
+        return Indicator;
+    }
+    catch {
+        return null;
+    }
+};
+const LOAD_INDICATOR_FACTORY_FN = singleshot(async () => {
+    let ctor = null;
+    if (ctor = REQUIRE_INDICATOR_FACTORY()) {
+        return ctor;
+    }
+    if (ctor = await IMPORT_INDICATOR_FACTORY()) {
+        return ctor;
+    }
+    throw new Error("PineTS import failed (useIndicator). Call useIndicator to provide a PineTS class to @backtest-kit/pinets.");
+});
+class IndicatorConnectionService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getInstance = async (...args) => {
+            this.loggerService.log("indicatorConnectionService getInstance", {
+                args,
+            });
+            if (!this.IndicatorFactory) {
+                this.IndicatorFactory = await LOAD_INDICATOR_FACTORY_FN();
+            }
+            if (!this.IndicatorFactory) {
+                throw new Error("PineTS import failed. Call useIndicator to provide a PineTS class to @backtest-kit/pinets.");
+            }
+            return Reflect.construct(this.IndicatorFactory, args);
+        };
+        this.useIndicator = (ctor) => {
+            this.loggerService.log("indicatorConnectionService useIndicator", {
+                ctor,
+            });
+            this.IndicatorFactory = ctor;
+        };
+        this.clear = () => {
+            this.loggerService.log("indicatorConnectionService clear");
+            LOAD_INDICATOR_FACTORY_FN.clear();
+            this.IndicatorFactory = null;
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -593,6 +668,7 @@ class PineMarkdownService {
 }
 {
     provide(TYPES.pineConnectionService, () => new PineConnectionService());
+    provide(TYPES.indicatorConnectionService, () => new IndicatorConnectionService());
 }
 {
     provide(TYPES.pineMarkdownService, () => new PineMarkdownService());
@@ -619,6 +695,7 @@ const cacheServices = {
 };
 const connectionServices = {
     pineConnectionService: inject(TYPES.pineConnectionService),
+    indicatorConnectionService: inject(TYPES.indicatorConnectionService),
 };
 const markdownServices = {
     pineMarkdownService: inject(TYPES.pineMarkdownService),
@@ -635,14 +712,22 @@ const pine = {
 };
 init();
 
-const METHOD_NAME_USE_PINE = "pine.usePine";
+const METHOD_NAME_USE_PINE$1 = "pine.usePine";
 function usePine(ctor) {
-    pine.loggerService.log(METHOD_NAME_USE_PINE, {
+    pine.loggerService.log(METHOD_NAME_USE_PINE$1, {
         ctor,
     });
     pine.pineConnectionService.usePine(ctor);
 }
 
+const METHOD_NAME_USE_PINE = "indicator.useIndicator";
+function useIndicator(ctor) {
+    pine.loggerService.log(METHOD_NAME_USE_PINE, {
+        ctor,
+    });
+    pine.indicatorConnectionService.useIndicator(ctor);
+}
+
 const METHOD_NAME_RUN$2 = "run.run";
 const GET_SOURCE_FN$2 = async (source) => {
     if (File.isFile(source)) {
@@ -654,14 +739,14 @@ const GET_SOURCE_FN$2 = async (source) => {
     }
     throw new Error("Source must be a File or Code instance");
 };
-const BASE_RUNNER_FN$1 = async (script, symbol, timeframe, limit) => await pine.pineJobService.run(script, symbol, timeframe, limit);
+const BASE_RUNNER_FN$1 = async (script, symbol, timeframe, limit, inputs) => await pine.pineJobService.run(script, symbol, timeframe, limit, inputs);
 const VALIDATE_NO_TRADING_FN$1 = () => {
     if (ExecutionContextService.hasContext()) {
         throw new Error(str.newline("Time overrides are not allowed when running scripts in a trading context.", "Please remove the 'when' parameter from the run function call."));
     }
 };
-const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, exchangeName, when) => {
-    let fn = () => BASE_RUNNER_FN$1(script, symbol, timeframe, limit);
+const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
+    let fn = () => BASE_RUNNER_FN$1(script, symbol, timeframe, limit, inputs);
     if (exchangeName) {
         fn = ExchangeContextService.runWithContext(fn, { exchangeName });
     }
@@ -674,14 +759,14 @@ const CREATE_INFERENCE_FN$1 = (script, symbol, timeframe, limit, exchangeName, w
     }
     return fn;
 };
-const RUN_INFERENCE_FN$1 = async (script, symbol, timeframe, limit, exchangeName, when) => {
+const RUN_INFERENCE_FN$1 = async (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
     if (when) {
         VALIDATE_NO_TRADING_FN$1();
     }
-    const inference = CREATE_INFERENCE_FN$1(script, symbol, timeframe, limit, exchangeName, when);
+    const inference = CREATE_INFERENCE_FN$1(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return await inference();
 };
-async function run(source, { symbol, timeframe, limit }, exchangeName, when) {
+async function run(source, { symbol, timeframe, limit, inputs = {} }, exchangeName, when) {
     pine.loggerService.info(METHOD_NAME_RUN$2, {
         source,
         symbol,
@@ -689,7 +774,7 @@ async function run(source, { symbol, timeframe, limit }, exchangeName, when) {
         limit,
     });
     const script = await GET_SOURCE_FN$2(source);
-    const { plots } = await RUN_INFERENCE_FN$1(script, symbol, timeframe, limit, exchangeName, when);
+    const { plots } = await RUN_INFERENCE_FN$1(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return plots;
 }
 
@@ -757,14 +842,14 @@ const SIGNAL_SCHEMA = {
         transform: (v) => v || DEFAULT_ESTIMATED_TIME,
     },
 };
-async function getSignal(source, { symbol, timeframe, limit }) {
+async function getSignal(source, { symbol, timeframe, limit, inputs = {} }) {
     pine.loggerService.info(METHOD_NAME_RUN, {
         source,
         symbol,
         timeframe,
         limit,
     });
-    const { plots } = await pine.pineJobService.run(await GET_SOURCE_FN$1(source), symbol, timeframe, limit);
+    const { plots } = await pine.pineJobService.run(await GET_SOURCE_FN$1(source), symbol, timeframe, limit, inputs);
     const resultId = randomString();
     const data = pine.pineDataService.extract(plots, SIGNAL_SCHEMA);
     return toSignalDto(resultId, data);
@@ -793,14 +878,14 @@ const GET_SOURCE_FN = async (source) => {
     }
     throw new Error("Source must be a File or Code instance");
 };
-const BASE_RUNNER_FN = async (script, symbol, timeframe, limit) => await pine.pineJobService.run(script, symbol, timeframe, limit);
+const BASE_RUNNER_FN = async (script, symbol, timeframe, limit, inputs) => await pine.pineJobService.run(script, symbol, timeframe, limit, inputs);
 const VALIDATE_NO_TRADING_FN = () => {
     if (ExecutionContextService.hasContext()) {
         throw new Error(str.newline("Time overrides are not allowed when running scripts in a trading context.", "Please remove the 'when' parameter from the run function call."));
     }
 };
-const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, exchangeName, when) => {
-    let fn = () => BASE_RUNNER_FN(script, symbol, timeframe, limit);
+const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
+    let fn = () => BASE_RUNNER_FN(script, symbol, timeframe, limit, inputs);
     if (exchangeName) {
         fn = ExchangeContextService.runWithContext(fn, { exchangeName });
     }
@@ -813,11 +898,11 @@ const CREATE_INFERENCE_FN = (script, symbol, timeframe, limit, exchangeName, whe
     }
     return fn;
 };
-const RUN_INFERENCE_FN = async (script, symbol, timeframe, limit, exchangeName, when) => {
+const RUN_INFERENCE_FN = async (script, symbol, timeframe, limit, inputs, exchangeName, when) => {
     if (when) {
         VALIDATE_NO_TRADING_FN();
     }
-    const inference = CREATE_INFERENCE_FN(script, symbol, timeframe, limit, exchangeName, when);
+    const inference = CREATE_INFERENCE_FN(script, symbol, timeframe, limit, inputs, exchangeName, when);
     return await inference();
 };
 async function toMarkdown(signalId, plots, mapping, limit = Number.POSITIVE_INFINITY) {
@@ -829,7 +914,7 @@ async function toMarkdown(signalId, plots, mapping, limit = Number.POSITIVE_INFI
     });
     return await pine.pineMarkdownService.getReport(signalId, plots, mapping, limit);
 }
-async function markdown(signalId, source, { symbol, timeframe, limit }, mapping, exchangeName, when) {
+async function markdown(signalId, source, { symbol, timeframe, limit, inputs = {} }, mapping, exchangeName, when) {
     pine.loggerService.log(MARKDOWN_METHOD_NAME, {
         signalId,
         mapping,
@@ -837,8 +922,8 @@ async function markdown(signalId, source, { symbol, timeframe, limit }, mapping,
         exchangeName,
         when,
     });
-    const { plots } = await RUN_INFERENCE_FN(await GET_SOURCE_FN(source), symbol, timeframe, limit, exchangeName, when);
+    const { plots } = await RUN_INFERENCE_FN(await GET_SOURCE_FN(source), symbol, timeframe, limit, inputs, exchangeName, when);
     return await pine.pineMarkdownService.getReport(signalId, plots, mapping, Number.POSITIVE_INFINITY);
 }
 
-export { AXIS_SYMBOL, Code, File, dumpPlotData, extract, getSignal, pine as lib, markdown, run, setLogger, toMarkdown, toSignalDto, usePine };
+export { AXIS_SYMBOL, Code, File, dumpPlotData, extract, getSignal, pine as lib, markdown, run, setLogger, toMarkdown, toSignalDto, useIndicator, usePine };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtest-kit/pinets",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Run TradingView Pine Script strategies in Node.js self hosted environment. Execute existing Pine Script indicators and generate trading signals with 1:1 syntax compatibility via PineTS runtime.",
   "author": {
     "name": "Petr Tripolsky",
@@ -69,12 +69,12 @@
     "ts-morph": "27.0.2",
     "tslib": "2.7.0",
     "typedoc": "0.27.9",
-    "backtest-kit": "3.4.0",
+    "backtest-kit": "3.5.0",
     "worker-testbed": "1.0.12"
   },
   "peerDependencies": {
-    "backtest-kit": "^3.4.0",
-    "pinets": "^0.8.11",
+    "backtest-kit": "^3.5.0",
+    "pinets": "^0.8.12",
     "typescript": "^5.0.0"
   },
   "dependencies": {

package/types.d.ts

@@ -29,19 +29,27 @@ type PlotRecord = {
     plots: PlotModel;
 };
 
+type TIndicatorCtor = new (source: string, inputs?: Record<string, any>) => IIndicator;
+interface IIndicator {
+    source: string;
+    inputs: Record<string, any>;
+}
+
 interface IProvider {
     getMarketData(tickerId: string, timeframe: string, limit?: number, sDate?: number, eDate?: number): Promise<any>;
     getSymbolInfo(tickerId: string): Promise<any>;
 }
 
-type TPineCtor = (source: IProvider, tickerId: string, timeframe: string, limit: number) => IPine;
+type TPineCtor = new (source: IProvider, tickerId: string, timeframe: string, limit: number) => IPine;
 interface IPine {
     ready(): Promise<void>;
-    run(code: string): Promise<PlotRecord>;
+    run(code: string | IIndicator): Promise<PlotRecord>;
 }
 
 declare function usePine<T = TPineCtor>(ctor: T): void;
 
+declare function useIndicator<T = TIndicatorCtor>(ctor: T): void;
+
 type ExchangeName = string;
 interface IExchangeContext {
     exchangeName: ExchangeName;
@@ -51,8 +59,9 @@ interface IRunParams$1 {
     symbol: string;
     timeframe: CandleInterval;
     limit: number;
+    inputs?: Record<string, any>;
 }
-declare function run(source: File | Code, { symbol, timeframe, limit }: IRunParams$1, exchangeName?: ExchangeName, when?: Date): Promise<PlotModel>;
+declare function run(source: File | Code, { symbol, timeframe, limit, inputs }: IRunParams$1, exchangeName?: ExchangeName, when?: Date): Promise<PlotModel>;
 
 type PlotExtractConfig<T = number> = {
     plot: string;
@@ -85,8 +94,9 @@ interface IParams {
     symbol: string;
     timeframe: CandleInterval;
     limit: number;
+    inputs?: Record<string, any>;
 }
-declare function getSignal(source: File | Code, { symbol, timeframe, limit }: IParams): Promise<ISignalDto | null>;
+declare function getSignal(source: File | Code, { symbol, timeframe, limit, inputs }: IParams): Promise<ISignalDto | null>;
 
 type ResultId$3 = string | number;
 declare function dumpPlotData<M extends PlotMapping>(signalId: ResultId$3, plots: PlotModel, mapping: M, taName: string, outputDir?: string): Promise<void>;
@@ -96,9 +106,10 @@ interface IRunParams {
     symbol: string;
     timeframe: CandleInterval;
     limit: number;
+    inputs?: Record<string, any>;
 }
 declare function toMarkdown<M extends PlotMapping>(signalId: ResultId$2, plots: PlotModel, mapping: M, limit?: number): Promise<string>;
-declare function markdown<M extends PlotMapping>(signalId: ResultId$2, source: File | Code, { symbol, timeframe, limit }: IRunParams, mapping: M, exchangeName?: ExchangeName, when?: Date): Promise<string>;
+declare function markdown<M extends PlotMapping>(signalId: ResultId$2, source: File | Code, { symbol, timeframe, limit, inputs }: IRunParams, mapping: M, exchangeName?: ExchangeName, when?: Date): Promise<string>;
 
 type ResultId$1 = string | number;
 interface SignalData {
@@ -160,17 +171,26 @@ declare class CandleProviderService implements IProvider {
 declare class PineConnectionService {
     private readonly loggerService;
     private PineFactory;
-    getInstance: (...args: Parameters<TPineCtor>) => Promise<IPine>;
+    getInstance: (...args: ConstructorParameters<TPineCtor>) => Promise<IPine>;
     usePine: (ctor: TPineCtor) => void;
     clear: () => void;
 }
 
+declare class IndicatorConnectionService {
+    private readonly loggerService;
+    private IndicatorFactory;
+    getInstance: (...args: ConstructorParameters<TIndicatorCtor>) => Promise<IIndicator>;
+    useIndicator: (ctor: TIndicatorCtor) => void;
+    clear: () => void;
+}
+
 declare class PineJobService {
     readonly loggerService: LoggerService;
     readonly axisProviderService: AxisProviderService;
     readonly candleProviderService: CandleProviderService;
     readonly pineConnectionService: PineConnectionService;
-    run: (code: Code, tickerId: string, timeframe?: CandleInterval, limit?: number) => Promise<PlotRecord>;
+    readonly indicatorConnectionService: IndicatorConnectionService;
+    run: (code: Code, tickerId: string, timeframe?: CandleInterval, limit?: number, inputs?: Record<string, any>) => Promise<PlotRecord>;
 }
 
 declare class PineCacheService {
@@ -194,6 +214,7 @@ declare class PineMarkdownService {
 declare const pine: {
     pineMarkdownService: PineMarkdownService;
     pineConnectionService: PineConnectionService;
+    indicatorConnectionService: IndicatorConnectionService;
     pineCacheService: PineCacheService;
     pineDataService: PineDataService;
     pineJobService: PineJobService;
@@ -205,4 +226,4 @@ declare const pine: {
     };
 };
 
-export { AXIS_SYMBOL, type CandleModel, Code, File, type ILogger, type IPine, type IProvider, type PlotExtractConfig, type PlotMapping, type PlotModel, type PlotRecord, type SymbolInfoModel, type TPineCtor, dumpPlotData, extract, getSignal, pine as lib, markdown, run, setLogger, toMarkdown, toSignalDto, usePine };
+export { AXIS_SYMBOL, type CandleModel, Code, File, type IIndicator, type ILogger, type IPine, type IProvider, type PlotExtractConfig, type PlotMapping, type PlotModel, type PlotRecord, type SymbolInfoModel, type TIndicatorCtor, type TPineCtor, dumpPlotData, extract, getSignal, pine as lib, markdown, run, setLogger, toMarkdown, toSignalDto, useIndicator, usePine };