pinets 0.3.0 → 0.5.0

package/dist/types/namespaces/ta/ta.index.d.ts

@@ -1,84 +1,199 @@
-import { tr } from './getters/tr';
+import { accdist } from './methods/accdist';
+import { alma } from './methods/alma';
 import { atr } from './methods/atr';
+import { barssince } from './methods/barssince';
+import { bb } from './methods/bb';
+import { bbw } from './methods/bbw';
+import { cci } from './methods/cci';
 import { change } from './methods/change';
+import { cmo } from './methods/cmo';
+import { cog } from './methods/cog';
+import { correlation } from './methods/correlation';
+import { cross } from './methods/cross';
 import { crossover } from './methods/crossover';
 import { crossunder } from './methods/crossunder';
+import { cum } from './methods/cum';
 import { dev } from './methods/dev';
+import { dmi } from './methods/dmi';
 import { ema } from './methods/ema';
+import { falling } from './methods/falling';
 import { highest } from './methods/highest';
+import { highestbars } from './methods/highestbars';
 import { hma } from './methods/hma';
+import { iii } from './methods/iii';
+import { kc } from './methods/kc';
+import { kcw } from './methods/kcw';
 import { linreg } from './methods/linreg';
 import { lowest } from './methods/lowest';
+import { lowestbars } from './methods/lowestbars';
+import { macd } from './methods/macd';
 import { median } from './methods/median';
+import { mfi } from './methods/mfi';
+import { mode } from './methods/mode';
 import { mom } from './methods/mom';
+import { nvi } from './methods/nvi';
+import { obv } from './methods/obv';
 import { param } from './methods/param';
+import { percentile_linear_interpolation } from './methods/percentile_linear_interpolation';
+import { percentile_nearest_rank } from './methods/percentile_nearest_rank';
+import { percentrank } from './methods/percentrank';
 import { pivothigh } from './methods/pivothigh';
 import { pivotlow } from './methods/pivotlow';
+import { pvi } from './methods/pvi';
+import { pvt } from './methods/pvt';
+import { range } from './methods/range';
+import { rising } from './methods/rising';
 import { rma } from './methods/rma';
 import { roc } from './methods/roc';
 import { rsi } from './methods/rsi';
+import { sar } from './methods/sar';
 import { sma } from './methods/sma';
 import { stdev } from './methods/stdev';
+import { stoch } from './methods/stoch';
 import { supertrend } from './methods/supertrend';
+import { swma } from './methods/swma';
+import { tr } from './methods/tr';
+import { tsi } from './methods/tsi';
+import { valuewhen } from './methods/valuewhen';
 import { variance } from './methods/variance';
+import { vwap } from './methods/vwap';
 import { vwma } from './methods/vwma';
+import { wad } from './methods/wad';
 import { wma } from './methods/wma';
-declare const getters: {
-    tr: typeof tr;
-};
+import { wpr } from './methods/wpr';
+import { wvad } from './methods/wvad';
 declare const methods: {
+    accdist: typeof accdist;
+    alma: typeof alma;
     atr: typeof atr;
+    barssince: typeof barssince;
+    bb: typeof bb;
+    bbw: typeof bbw;
+    cci: typeof cci;
     change: typeof change;
+    cmo: typeof cmo;
+    cog: typeof cog;
+    correlation: typeof correlation;
+    cross: typeof cross;
     crossover: typeof crossover;
     crossunder: typeof crossunder;
+    cum: typeof cum;
     dev: typeof dev;
+    dmi: typeof dmi;
     ema: typeof ema;
+    falling: typeof falling;
     highest: typeof highest;
+    highestbars: typeof highestbars;
     hma: typeof hma;
+    iii: typeof iii;
+    kc: typeof kc;
+    kcw: typeof kcw;
     linreg: typeof linreg;
     lowest: typeof lowest;
+    lowestbars: typeof lowestbars;
+    macd: typeof macd;
     median: typeof median;
+    mfi: typeof mfi;
+    mode: typeof mode;
     mom: typeof mom;
+    nvi: typeof nvi;
+    obv: typeof obv;
     param: typeof param;
+    percentile_linear_interpolation: typeof percentile_linear_interpolation;
+    percentile_nearest_rank: typeof percentile_nearest_rank;
+    percentrank: typeof percentrank;
     pivothigh: typeof pivothigh;
     pivotlow: typeof pivotlow;
+    pvi: typeof pvi;
+    pvt: typeof pvt;
+    range: typeof range;
+    rising: typeof rising;
     rma: typeof rma;
     roc: typeof roc;
     rsi: typeof rsi;
+    sar: typeof sar;
     sma: typeof sma;
     stdev: typeof stdev;
+    stoch: typeof stoch;
     supertrend: typeof supertrend;
+    swma: typeof swma;
+    tr: typeof tr;
+    tsi: typeof tsi;
+    valuewhen: typeof valuewhen;
     variance: typeof variance;
+    vwap: typeof vwap;
     vwma: typeof vwma;
+    wad: typeof wad;
     wma: typeof wma;
+    wpr: typeof wpr;
+    wvad: typeof wvad;
 };
 export declare class TechnicalAnalysis {
     private context;
-    readonly tr: ReturnType<ReturnType<typeof getters.tr>>;
+    accdist: ReturnType<typeof methods.accdist>;
+    alma: ReturnType<typeof methods.alma>;
     atr: ReturnType<typeof methods.atr>;
+    barssince: ReturnType<typeof methods.barssince>;
+    bb: ReturnType<typeof methods.bb>;
+    bbw: ReturnType<typeof methods.bbw>;
+    cci: ReturnType<typeof methods.cci>;
     change: ReturnType<typeof methods.change>;
+    cmo: ReturnType<typeof methods.cmo>;
+    cog: ReturnType<typeof methods.cog>;
+    correlation: ReturnType<typeof methods.correlation>;
+    cross: ReturnType<typeof methods.cross>;
     crossover: ReturnType<typeof methods.crossover>;
     crossunder: ReturnType<typeof methods.crossunder>;
+    cum: ReturnType<typeof methods.cum>;
     dev: ReturnType<typeof methods.dev>;
+    dmi: ReturnType<typeof methods.dmi>;
     ema: ReturnType<typeof methods.ema>;
+    falling: ReturnType<typeof methods.falling>;
     highest: ReturnType<typeof methods.highest>;
+    highestbars: ReturnType<typeof methods.highestbars>;
     hma: ReturnType<typeof methods.hma>;
+    iii: ReturnType<typeof methods.iii>;
+    kc: ReturnType<typeof methods.kc>;
+    kcw: ReturnType<typeof methods.kcw>;
     linreg: ReturnType<typeof methods.linreg>;
     lowest: ReturnType<typeof methods.lowest>;
+    lowestbars: ReturnType<typeof methods.lowestbars>;
+    macd: ReturnType<typeof methods.macd>;
     median: ReturnType<typeof methods.median>;
+    mfi: ReturnType<typeof methods.mfi>;
+    mode: ReturnType<typeof methods.mode>;
     mom: ReturnType<typeof methods.mom>;
+    nvi: ReturnType<typeof methods.nvi>;
+    obv: ReturnType<typeof methods.obv>;
     param: ReturnType<typeof methods.param>;
+    percentile_linear_interpolation: ReturnType<typeof methods.percentile_linear_interpolation>;
+    percentile_nearest_rank: ReturnType<typeof methods.percentile_nearest_rank>;
+    percentrank: ReturnType<typeof methods.percentrank>;
     pivothigh: ReturnType<typeof methods.pivothigh>;
     pivotlow: ReturnType<typeof methods.pivotlow>;
+    pvi: ReturnType<typeof methods.pvi>;
+    pvt: ReturnType<typeof methods.pvt>;
+    range: ReturnType<typeof methods.range>;
+    rising: ReturnType<typeof methods.rising>;
     rma: ReturnType<typeof methods.rma>;
     roc: ReturnType<typeof methods.roc>;
     rsi: ReturnType<typeof methods.rsi>;
+    sar: ReturnType<typeof methods.sar>;
     sma: ReturnType<typeof methods.sma>;
     stdev: ReturnType<typeof methods.stdev>;
+    stoch: ReturnType<typeof methods.stoch>;
     supertrend: ReturnType<typeof methods.supertrend>;
+    swma: ReturnType<typeof methods.swma>;
+    tr: ReturnType<typeof methods.tr>;
+    tsi: ReturnType<typeof methods.tsi>;
+    valuewhen: ReturnType<typeof methods.valuewhen>;
     variance: ReturnType<typeof methods.variance>;
+    vwap: ReturnType<typeof methods.vwap>;
     vwma: ReturnType<typeof methods.vwma>;
+    wad: ReturnType<typeof methods.wad>;
     wma: ReturnType<typeof methods.wma>;
+    wpr: ReturnType<typeof methods.wpr>;
+    wvad: ReturnType<typeof methods.wvad>;
     constructor(context: any);
 }
 export default TechnicalAnalysis;

package/dist/types/transpiler/analysis/ScopeManager.d.ts

@@ -5,6 +5,7 @@ export declare class ScopeManager {
     private contextBoundVars;
     private arrayPatternElements;
     private rootParams;
+    private localSeriesVars;
     private varKinds;
     private loopVars;
     private loopVarNames;
@@ -12,6 +13,8 @@ export declare class ScopeManager {
     private cacheIdCounter;
     private tempVarCounter;
     private taCallIdCounter;
+    private hoistingStack;
+    private suppressHoisting;
     get nextParamIdArg(): any;
     get nextCacheIdArg(): any;
     getNextTACallId(): any;
@@ -20,6 +23,8 @@ export declare class ScopeManager {
     popScope(): void;
     getCurrentScopeType(): string;
     getCurrentScopeCount(): number;
+    addLocalSeriesVar(name: string): void;
+    isLocalSeriesVar(name: string): boolean;
     addContextBoundVar(name: string, isRootParam?: boolean): void;
     removeContextBoundVar(name: any): void;
     addArrayPatternElement(name: string): void;
@@ -32,5 +37,11 @@ export declare class ScopeManager {
     addVariable(name: string, kind: string): string;
     getVariable(name: string): [string, string];
     generateTempVar(): string;
+    enterHoistingScope(): void;
+    exitHoistingScope(): any[];
+    addHoistedStatement(stmt: any): void;
+    setSuppressHoisting(suppress: boolean): void;
+    shouldSuppressHoisting(): boolean;
+    generateParamId(): string;
 }
 export default ScopeManager;

package/dist/types/transpiler/index.d.ts

@@ -1 +1,4 @@
-export declare function transpile(fn: string | Function): Function;
+export declare function transpile(fn: string | Function, options?: {
+    debug: boolean;
+    ln?: boolean;
+}): Function;

package/dist/types/transpiler/transformers/InjectionTransformer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Injects implicit imports for missing context variables (data and pine namespaces)
+ * This ensures that users don't have to manually destructure context.data or context.pine
+ * @param ast The AST to transform
+ */
+export declare function injectImplicitImports(ast: any): void;

package/dist/types/transpiler/transformers/MainTransformer.d.ts

@@ -1,3 +1,6 @@
 import ScopeManager from '../analysis/ScopeManager';
 export declare function transformEqualityChecks(ast: any): void;
-export declare function runTransformationPass(ast: any, scopeManager: ScopeManager, originalParamName: string): void;
+export declare function runTransformationPass(ast: any, scopeManager: ScopeManager, originalParamName: string, options?: {
+    debug: boolean;
+    ln?: boolean;
+}, sourceLines?: string[]): void;

package/dist/types/transpiler/transformers/NormalizationTransformer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Normalizes imports from context.data and context.pine to prevent renaming of native symbols.
+ * This ensures that symbols like 'close' or 'na' are always named 'close' and 'na' in the local scope,
+ * satisfying the transpiler's expectation for exact naming of context-bound variables.
+ *
+ * Transforms:
+ * const { close: close2 } = context.data;
+ * to
+ * const { close } = context.data;
+ *
+ * And renames all usages of 'close2' to 'close' within the scope.
+ *
+ * @param ast The AST to transform
+ */
+export declare function normalizeNativeImports(ast: any): void;

package/dist/types/transpiler/transformers/WrapperTransformer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wraps unwrapped code in a context arrow function.
+ * If the code is already wrapped in a function, returns it as-is.
+ * Otherwise, wraps it in: (context) => { ... }
+ *
+ * @param code The input code string
+ * @returns The wrapped code string
+ */
+export declare function wrapInContextFunction(code: string): string;

package/dist/types/transpiler/utils/ASTFactory.d.ts

@@ -11,8 +11,10 @@ export declare const ASTFactory: {
     createAssignmentExpression(left: any, right: any, operator?: string): any;
     createExpressionStatement(expression: any): any;
     createInitCall(targetVarRef: any, value: any, lookbehind?: any): any;
+    createInitVarCall(targetVarRef: any, value: any): any;
     createGetCall(source: any, index: any): any;
     createSetCall(target: any, value: any): any;
     createMathEqCall(left: any, right: any): any;
     createWrapperFunction(body: any): any;
+    createVariableDeclaration(name: string, init: any): any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "",
     "main": "dist/pinets.dev.es.js",
     "types": "dist/types/index.d.ts",