{
+ return {
+ hasError: true,
+ error
+ };
+ }
+
+ componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+ this.setState({
+ error,
+ errorInfo
+ });
+
+ // Log error to console for debugging
+ console.error('Error caught by boundary:', error, errorInfo);
+ }
+
+ handleRetry = (): void => {
+ this.setState({
+ hasError: false,
+ error: null,
+ errorInfo: null
+ });
+ };
+
+ render() {
+ if (this.state.hasError) {
+ // Use custom fallback if provided
+ if (this.props.fallback) {
+ const FallbackComponent = this.props.fallback;
+ return ;
+ }
+
+ // Default error UI
+ return (
+
+
+
+ Component Error
+
+
+
+
+
+ {this.state.error?.message || 'An unexpected error occurred'}
+
+
+ {process.env.NODE_ENV === 'development' && this.state.errorInfo && (
+
+
+ Stack trace
+
+
+ {this.state.errorInfo.componentStack}
+
+
+ )}
+
+ {this.props.children}
+
+ );
+ }
+}
+
+// Higher-order component for easier usage
+export function withErrorBoundary(
+ Component: React.ComponentType
,
+ fallback?: React.ComponentType<{ error: Error }>
+): React.FC
{
+ return function WrappedComponent(props: P) {
+ return (
+
+
+
+ );
+ };
+}
+
+// Example usage of custom fallback:
+/*
+const CustomFallback: React.FC<{ error: Error }> = ({ error }) => (
+
+
Something went wrong
+
{error.message}
+
Column 1
+ Column 2
+
+
+ );
+};
\ No newline at end of file
diff --git a/src/components/ui/card - Copy - Copy.tsx b/src/components/ui/card - Copy - Copy.tsx
new file mode 100644
index 0000000..e69de29
diff --git a/src/components/ui/card.tsx b/src/components/ui/card.tsx
new file mode 100644
index 0000000..152bb32
--- /dev/null
+++ b/src/components/ui/card.tsx
@@ -0,0 +1,79 @@
+import * as React from "react"
+
+import { cn } from "src/lib/utils"
+
+const Card = React.forwardRef<
+ HTMLDivElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+Card.displayName = "Card"
+
+const CardHeader = React.forwardRef<
+ HTMLDivElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+CardHeader.displayName = "CardHeader"
+
+const CardTitle = React.forwardRef<
+ HTMLParagraphElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+CardTitle.displayName = "CardTitle"
+
+const CardDescription = React.forwardRef<
+ HTMLParagraphElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+CardDescription.displayName = "CardDescription"
+
+const CardContent = React.forwardRef<
+ HTMLDivElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+CardContent.displayName = "CardContent"
+
+const CardFooter = React.forwardRef<
+ HTMLDivElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+))
+CardFooter.displayName = "CardFooter"
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
diff --git a/src/components/ui/switch.tsx b/src/components/ui/switch.tsx
new file mode 100644
index 0000000..39bea05
--- /dev/null
+++ b/src/components/ui/switch.tsx
@@ -0,0 +1,29 @@
+"use client"
+
+import * as React from "react"
+import * as SwitchPrimitives from "@radix-ui/react-switch"
+
+import { cn } from "src/lib/utils"
+
+const Switch = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+
+
+))
+Switch.displayName = SwitchPrimitives.Root.displayName
+
+export { Switch }
\ No newline at end of file
diff --git a/src/components/ui/tabs.tsx b/src/components/ui/tabs.tsx
new file mode 100644
index 0000000..7b5227b
--- /dev/null
+++ b/src/components/ui/tabs.tsx
@@ -0,0 +1,52 @@
+import * as React from "react"
+import * as TabsPrimitive from "@radix-ui/react-tabs"
+import { cn } from "src/lib/utils"
+
+const Tabs = TabsPrimitive.Root
+
+const TabsList = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+))
+TabsList.displayName = TabsPrimitive.List.displayName
+
+const TabsTrigger = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+))
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName
+
+const TabsContent = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+))
+TabsContent.displayName = TabsPrimitive.Content.displayName
+
+export { Tabs, TabsList, TabsTrigger, TabsContent }
\ No newline at end of file
diff --git a/src/core/dynamic.tsx b/src/core/dynamic.tsx
new file mode 100644
index 0000000..229e42b
--- /dev/null
+++ b/src/core/dynamic.tsx
@@ -0,0 +1,84 @@
+// src/core/dynamic.tsx
+import React, {
+ useEffect,
+ useState,
+ ComponentType,
+ FC,
+ ComponentProps,
+ ReactElement
+} from 'react';
+
+interface DynamicOptions {
+ loading?: ComponentType;
+ error?: ComponentType<{ error: Error }>;
+}
+
+type ImportFunction = () => Promise<{ default: T }>;
+
+const DefaultError: FC<{ error: Error }> = ({ error }): ReactElement => {
+ return (
+
+ Error loading component: {error.message}
+
+ );
+};
+
+const DefaultLoading: FC = (): ReactElement => {
+ return Loading...
;
+};
+
+export function dynamic>(
+ importFn: ImportFunction,
+ options: DynamicOptions = {}
+): FC> {
+ const LoadingComponent: ComponentType = options.loading || DefaultLoading;
+ const ErrorComponent: ComponentType<{ error: Error }> = options.error || DefaultError;
+
+ const DynamicComponent: FC> = (props): ReactElement => {
+ const [Component, setComponent] = useState(null);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ let mounted = true;
+
+ const loadComponent = async (): Promise => {
+ try {
+ const module = await importFn();
+ if (mounted) {
+ setComponent(() => module.default);
+ }
+ } catch (err) {
+ if (mounted) {
+ setError(err instanceof Error ? err : new Error('Failed to load component'));
+ }
+ }
+ };
+
+ loadComponent();
+ return () => { mounted = false; };
+ }, []);
+
+ if (error) {
+ return ;
+ }
+
+ if (!Component) {
+ return ;
+ }
+
+ return ;
+ };
+
+ return DynamicComponent;
+}
+
+// Version for named exports
+export function dynamicNamed>(
+ importFn: () => Promise,
+ options: DynamicOptions = {}
+): FC> {
+ return dynamic(
+ async () => ({ default: await importFn() }),
+ options
+ );
+}
\ No newline at end of file
diff --git a/src/core/registry.tsx b/src/core/registry.tsx
new file mode 100644
index 0000000..9728271
--- /dev/null
+++ b/src/core/registry.tsx
@@ -0,0 +1,47 @@
+// src/core/registry.tsx
+import React, { FC, ComponentProps } from 'react';
+import { dynamic, dynamicNamed } from './dynamic';
+
+interface Registry {
+ PieChart: FC>;
+ Chart: FC>;
+ ForceGraph2D: FC>;
+ [key: string]: FC>; // Add index signature
+ Pie: FC>;
+ Cell: FC>;
+ ResponsiveContainer: FC>;
+ Tooltip: FC>;
+ Legend: FC>;
+}
+
+export const ComponentRegistry: Registry = {
+ // For named exports from recharts, use dynamicNamed
+ PieChart: dynamicNamed(() =>
+ import('recharts').then(mod => mod.PieChart)
+ ),
+ Pie: dynamicNamed(() =>
+ import('recharts').then(mod => mod.Pie)
+ ),
+ Cell: dynamicNamed(() =>
+ import('recharts').then(mod => mod.Cell)
+ ),
+ ResponsiveContainer: dynamicNamed(() =>
+ import('recharts').then(mod => mod.ResponsiveContainer)
+ ),
+ Tooltip: dynamicNamed(() =>
+ import('recharts').then(mod => mod.Tooltip)
+ ),
+ Legend: dynamicNamed(() =>
+ import('recharts').then(mod => mod.Legend)
+ ),
+
+ // For components with default exports, use dynamic
+ Chart: dynamic(() => import('react-apexcharts')),
+ ForceGraph2D: dynamicNamed(() =>
+ import('react-force-graph').then(mod => mod.ForceGraph2D)
+ )
+};
+
+export const getRegisteredComponent = (name: string): FC> | null => {
+ return ComponentRegistry[name] || null;
+};
\ No newline at end of file
diff --git a/src/core/scope.ts b/src/core/scope.ts
new file mode 100644
index 0000000..71db892
--- /dev/null
+++ b/src/core/scope.ts
@@ -0,0 +1,212 @@
+// src/core/scope.ts
+import React from 'react';
+import { App } from 'obsidian';
+
+interface ScopeOptions {
+ app?: App;
+ parentScope?: ComponentScope;
+ isGlobal?: boolean;
+}
+
+export class ComponentScope {
+ private static instances = new Map();
+ private static globalScope: ComponentScope | null = null;
+
+ private variables = new Map();
+ private children = new Set();
+ private readonly defaultScope: Record;
+
+ constructor(
+ private readonly id: string,
+ private readonly options: ScopeOptions = {}
+ ) {
+ // Initialize default React scope
+ this.defaultScope = {
+ React,
+ useState: React.useState,
+ useEffect: React.useEffect,
+ useRef: React.useRef,
+ useMemo: React.useMemo,
+ useCallback: React.useCallback,
+ useContext: React.useContext,
+ // Add Obsidian app if available
+ app: options.app,
+ };
+
+ if (options.isGlobal) {
+ ComponentScope.globalScope = this;
+ } else if (options.parentScope) {
+ options.parentScope.addChild(this);
+ }
+
+ ComponentScope.instances.set(id, this);
+ }
+
+ // Get a value from scope
+ get(name: string): any {
+ // Check local variables first
+ if (this.variables.has(name)) {
+ return this.variables.get(name);
+ }
+
+ // Check default scope
+ if (name in this.defaultScope) {
+ return this.defaultScope[name];
+ }
+
+ // Check parent scope
+ if (this.options.parentScope) {
+ return this.options.parentScope.get(name);
+ }
+
+ // Check global scope as last resort
+ if (!this.options.isGlobal && ComponentScope.globalScope) {
+ return ComponentScope.globalScope.get(name);
+ }
+
+ return undefined;
+ }
+
+ // Set a value in scope
+ set(name: string, value: any): void {
+ this.variables.set(name, value);
+ }
+
+ // Remove a value from scope
+ delete(name: string): boolean {
+ return this.variables.delete(name);
+ }
+
+ // Check if scope has a variable
+ has(name: string): boolean {
+ return (
+ this.variables.has(name) ||
+ name in this.defaultScope ||
+ (this.options.parentScope?.has(name) ?? false) ||
+ (!this.options.isGlobal && (ComponentScope.globalScope?.has(name) ?? false))
+ );
+ }
+
+ // Add a child scope
+ private addChild(scope: ComponentScope): void {
+ this.children.add(scope);
+ }
+
+ // Remove a child scope
+ private removeChild(scope: ComponentScope): void {
+ this.children.delete(scope);
+ }
+
+ // Clear all variables in this scope
+ clear(): void {
+ this.variables.clear();
+ }
+
+ // Dispose of this scope
+ dispose(): void {
+ if (this.options.parentScope) {
+ this.options.parentScope.removeChild(this);
+ }
+ ComponentScope.instances.delete(this.id);
+ this.clear();
+
+ // Dispose of all children
+ this.children.forEach(child => child.dispose());
+ this.children.clear();
+ }
+
+ // Get all variables in this scope (including inherited)
+ getAllVariables(): Record {
+ const variables: Record = {
+ ...this.defaultScope,
+ ...Object.fromEntries(this.variables)
+ };
+
+ if (this.options.parentScope) {
+ return {
+ ...this.options.parentScope.getAllVariables(),
+ ...variables
+ };
+ }
+
+ return variables;
+ }
+
+ // Static methods for scope management
+ static getScope(id: string): ComponentScope | undefined {
+ return this.instances.get(id);
+ }
+
+ static createScope(id: string, options: ScopeOptions = {}): ComponentScope {
+ if (this.instances.has(id)) {
+ throw new Error(`Scope with id "${id}" already exists`);
+ }
+ return new ComponentScope(id, options);
+ }
+
+ static getOrCreateScope(id: string, options: ScopeOptions = {}): ComponentScope {
+ return this.instances.get(id) || new ComponentScope(id, options);
+ }
+
+ static disposeScope(id: string): void {
+ const scope = this.instances.get(id);
+ if (scope) {
+ scope.dispose();
+ }
+ }
+
+ // Create a hook for React components to access scope
+ static createScopeHook(scopeId: string) {
+ return function useScopeValue(name: string) {
+ const scope = ComponentScope.getScope(scopeId);
+ if (!scope) {
+ throw new Error(`Scope "${scopeId}" not found`);
+ }
+ return scope.get(name);
+ };
+ }
+}
+
+// Helper function to create a new component scope
+export function createComponentScope(
+ id: string,
+ app?: App,
+ parentScope?: ComponentScope
+): ComponentScope {
+ return new ComponentScope(id, { app, parentScope });
+}
+
+// React hook for accessing scope
+export function useComponentScope(scopeId: string) {
+ return React.useMemo(() => {
+ const scope = ComponentScope.getScope(scopeId);
+ if (!scope) {
+ throw new Error(`Scope "${scopeId}" not found`);
+ }
+ return scope;
+ }, [scopeId]);
+}
+
+// Example usage:
+/*
+// Create a global scope
+const globalScope = new ComponentScope('global', { isGlobal: true });
+globalScope.set('sharedValue', 42);
+
+// Create a component scope
+const componentScope = createComponentScope('component-1', app);
+componentScope.set('localValue', 'hello');
+
+// In a React component:
+function MyComponent() {
+ const scope = useComponentScope('component-1');
+ const localValue = scope.get('localValue');
+ const sharedValue = scope.get('sharedValue');
+
+ return (
+
+ Local: {localValue}, Shared: {sharedValue}
+
+ );
+}
+*/
\ No newline at end of file
diff --git a/src/core/storage.ts b/src/core/storage.ts
new file mode 100644
index 0000000..96c6bff
--- /dev/null
+++ b/src/core/storage.ts
@@ -0,0 +1,109 @@
+// src/core/storage.tsx
+import { MarketDataService, MarketData } from '../services/marketDataService';
+import { Plugin, TFile,parseYaml,stringifyYaml } from 'obsidian';
+export class StorageManager {
+ private plugin: Plugin;
+ private cache: Map;
+
+ constructor(plugin: Plugin) {
+ this.plugin = plugin;
+ this.cache = new Map();
+ }
+
+ private getCacheKey(noteFile: TFile, key: string): string {
+ return `${noteFile.path}:${key}`;
+ }
+
+ private async getFrontmatter(noteFile: TFile) {
+ const metadata = this.plugin.app.metadataCache.getFileCache(noteFile)?.frontmatter;
+ return metadata?.react_data || {};
+ }
+ async getMarketData(symbol: string, interval: string, range: string, noteFile: TFile): Promise {
+ const cacheKey = `market-data-${symbol}-${interval}-${range}`;
+
+ // Get from frontmatter
+ const frontmatter = await this.getFrontmatter(noteFile);
+ const cached = frontmatter[cacheKey];
+
+ // Check if we have cached data and if it's still fresh (24 hours)
+ if (cached && Date.now() - cached.timestamp < 24 * 60 * 60 * 1000) {
+ return cached.data;
+ }
+
+ // Fetch new data
+ const data = (await MarketDataService.fetchHistoricalData(symbol)).data;
+
+ // Cache the data using existing set method
+ await this.set(cacheKey, {
+ data,
+ timestamp: Date.now()
+ }, noteFile);
+
+ return data;
+ }
+ async get(key: string, defaultValue: T, noteFile: TFile): Promise {
+ const cacheKey = this.getCacheKey(noteFile, key);
+
+ // Check cache first
+ if (this.cache.has(cacheKey)) {
+ return this.cache.get(cacheKey);
+ }
+
+ // Get from frontmatter
+ const frontmatter = await this.getFrontmatter(noteFile);
+ const value = frontmatter[key] ?? defaultValue;
+
+ // Update cache
+ this.cache.set(cacheKey, value);
+ return value;
+ }
+
+ async set(key: string, value: T, noteFile: TFile): Promise {
+ const cacheKey = this.getCacheKey(noteFile, key);
+ this.cache.set(cacheKey, value);
+
+ const content = await this.plugin.app.vault.read(noteFile);
+ const frontmatter = await this.getFrontmatter(noteFile);
+
+ // Prepare new frontmatter
+ const newFrontmatter = {
+ ...frontmatter,
+ [key]: value
+ };
+
+ // Update the file with new frontmatter
+ const updatedContent = this.updateFrontmatter(content, newFrontmatter);
+ await this.plugin.app.vault.modify(noteFile, updatedContent);
+ }
+
+ private updateFrontmatter(content: string, newData: any): string {
+ const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+ const frontmatterMatch = content.match(frontmatterRegex);
+
+ if (frontmatterMatch) {
+ // Update existing frontmatter
+ let frontmatter;
+ try {
+ frontmatter = parseYaml(frontmatterMatch[1]);
+ } catch (e) {
+ frontmatter = {};
+ }
+
+ frontmatter.react_data = {
+ ...frontmatter.react_data,
+ ...newData
+ };
+
+ const newFrontmatter = stringifyYaml(frontmatter);
+ return content.replace(frontmatterRegex, `---\n${newFrontmatter}---`);
+ } else {
+ // Create new frontmatter
+ const newFrontmatter = stringifyYaml({ react_data: newData });
+ return `---\n${newFrontmatter}---\n\n${content}`;
+ }
+ }
+
+ clearCache() {
+ this.cache.clear();
+ }
+}
\ No newline at end of file
diff --git a/src/core/styles.ts b/src/core/styles.ts
new file mode 100644
index 0000000..392ceaa
--- /dev/null
+++ b/src/core/styles.ts
@@ -0,0 +1,80 @@
+// src/core/styles.ts
+export const componentStyles = {
+ // Base component styles
+ reactComponent: `
+ padding: 1rem;
+ border-radius: 0.5rem;
+ box-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+ `,
+
+ // Button styles
+ reactComponentButton: `
+ padding: 0.5rem 1rem;
+ color: var(--text-on-accent);
+ background-color: var(--interactive-accent);
+ border-radius: 0.25rem;
+
+ &:hover {
+ background-color: var(--interactive-accent-hover);
+ }
+ `,
+
+ // Chart-specific styles
+ chartContainer: (theme: 'dark' | 'light') => `
+ background: ${theme === 'dark' ? '#1e293b' : '#ffffff'};
+ color: ${theme === 'dark' ? '#94a3b8' : '#475569'};
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 0.5rem;
+ min-height: 400px;
+ `,
+
+ // List styles
+ listContent: `
+ margin: 0;
+ padding-left: 1.5rem;
+ list-style-type: none;
+
+ li {
+ margin-bottom: 0.5rem;
+ color: var(--text-normal);
+ }
+ `,
+};
+
+// Common utility classes that don't need runtime processing
+export const utilityClasses = {
+ layout: {
+ 'w-full': 'width: 100%;',
+ 'grid': 'display: grid;',
+ 'grid-cols-2': 'grid-template-columns: repeat(2, minmax(0, 1fr));',
+ 'gap-4': 'gap: 1rem;',
+ },
+ spacing: {
+ 'mt-4': 'margin-top: 1rem;',
+ 'mb-2': 'margin-bottom: 0.5rem;',
+ 'p-4': 'padding: 1rem;',
+ },
+ colors: {
+ 'text-green-500': 'color: var(--color-green);',
+ 'text-red-500': 'color: var(--color-red);',
+ 'text-blue-500': 'color: var(--interactive-accent);',
+ }
+};
+
+// Theme-aware chart configuration
+export const getChartConfig = (theme: 'dark' | 'light') => ({
+ layout: {
+ background: {
+ color: theme === 'dark' ? '#1e293b' : '#ffffff'
+ },
+ textColor: theme === 'dark' ? '#94a3b8' : '#475569',
+ },
+ grid: {
+ vertLines: {
+ color: theme === 'dark' ? '#334155' : '#e2e8f0'
+ },
+ horzLines: {
+ color: theme === 'dark' ? '#334155' : '#e2e8f0'
+ },
+ }
+});
\ No newline at end of file
diff --git a/src/core/tailwind.ts b/src/core/tailwind.ts
new file mode 100644
index 0000000..6e36170
--- /dev/null
+++ b/src/core/tailwind.ts
@@ -0,0 +1,34 @@
+// src/core/tailwind.ts
+import postcss from 'postcss';
+import tailwindcss from 'tailwindcss';
+import autoprefixer from 'autoprefixer';
+
+export class TailwindProcessor {
+ private config: any;
+
+ constructor() {
+ this.config = {
+ content: ['./src/**/*.{ts,tsx}'],
+ theme: {
+ extend: {},
+ },
+ // Disable preflight to avoid conflicts with Obsidian
+ corePlugins: {
+ preflight: false
+ }
+ };
+ }
+
+ // Process Tailwind CSS
+ async process(css: string): Promise {
+ const result = await postcss([
+ tailwindcss(this.config),
+ autoprefixer
+ ]).process(css, {
+ from: undefined
+ });
+
+ return result.css;
+ }
+}
+
diff --git a/src/core/transformer.ts b/src/core/transformer.ts
new file mode 100644
index 0000000..c4d5fc4
--- /dev/null
+++ b/src/core/transformer.ts
@@ -0,0 +1,205 @@
+// src/core/transformer.ts
+import { transform as babelTransform } from '@babel/standalone';
+
+interface TransformOptions {
+ scope?: Record;
+ filename?: string;
+ isTypeScript?: boolean;
+ isInline?: boolean;
+}
+
+interface TransformResult {
+ code: string;
+ component: React.ComponentType;
+ error?: Error;
+}
+
+export class ComponentTransformer {
+ private static defaultScope = {
+ React: window.React,
+ useState: window.React.useState,
+ useEffect: window.React.useEffect,
+ useRef: window.React.useRef,
+ useMemo: window.React.useMemo,
+ useCallback: window.React.useCallback,
+ };
+
+ static async transform(code: string, options: TransformOptions = {}): Promise {
+ try {
+ // Prepare the code
+ const processedCode = this.preprocessCode(code, options);
+
+ // Transform the code using Babel
+ const transformed = await this.babelTransform(processedCode, options);
+
+ // Create the component
+ const component = await this.createComponent(transformed, options);
+
+ return {
+ code: transformed,
+ component
+ };
+ } catch (error) {
+ console.error('Transformation error:', error);
+ throw this.enhanceError(error);
+ }
+ }
+
+ private static preprocessCode(code: string, options: TransformOptions): string {
+ // Remove imports and exports first
+ code = code.replace(/import\s+.*?['"];?\s*$/gm, '');
+ code = code.replace(/import\s*{[^}]*}\s*from\s*['"][^'"]*['"];?\s*$/gm, '');
+ code = code.replace(/import\s*\([^)]*\);?\s*$/gm, '');
+ code = code.replace(/export\s+default\s+/, '');
+ code = code.replace(/export\s+const\s+/, 'const ');
+ code = code.replace(/export\s+function\s+/, 'function ');
+ code = code.replace(/export\s+class\s+/, 'class ');
+
+ // Handle any named component/function conversion to Component
+ const namedComponentMatch = code.match(/const\s+(\w+)\s*=\s*\(\)\s*=>/);
+ if (namedComponentMatch) {
+ code = code.replace(
+ `const ${namedComponentMatch[1]} = () =>`,
+ 'const Component = () =>'
+ );
+ } else if (!code.includes('const Component =') && !code.includes('function Component')) {
+ code = `const Component = () => ${code}`;
+ }
+
+ return `
+ try {
+ ${code}
+ } catch (error) {
+ console.error('Error in component code:', error);
+ throw error;
+ }
+ `;
+ }
+
+ private static async babelTransform(code: string, options: TransformOptions): Promise {
+ const transformed = babelTransform(code, {
+ presets: [
+ 'react',
+ ...(options.isTypeScript ? ['typescript'] : [])
+ ] as string[],
+ filename: options.filename || 'component.jsx',
+ sourceType: 'module',
+ configFile: false,
+ babelrc: false,
+ plugins: [
+ // Add any custom plugins here
+ this.createScopePlugin(options.scope)
+ ]
+ });
+
+ return transformed.code;
+ }
+
+ private static async createComponent(code: string, options: TransformOptions): Promise {
+ // Create the scope with defaults and custom additions
+ const scope = {
+ ...this.defaultScope,
+ ...options.scope
+ };
+
+ // Create the component function
+ const componentFn = new Function(
+ ...Object.keys(scope),
+ `
+ ${code}
+ return typeof Component !== 'undefined'
+ ? Component
+ : () => null;
+ `
+ );
+
+ try {
+ // Execute with scope
+ return componentFn(...Object.values(scope));
+ } catch (error) {
+ throw new Error(`Error creating component: ${error.message}`);
+ }
+ }
+
+ private static createScopePlugin(customScope: Record = {}) {
+ // Custom babel plugin to handle scope
+ return {
+ visitor: {
+ Identifier(path: any) {
+ const name = path.node.name;
+ if (
+ path.scope.hasBinding(name) ||
+ this.defaultScope.hasOwnProperty(name) ||
+ customScope.hasOwnProperty(name)
+ ) {
+ return;
+ }
+
+ // Replace unknown identifiers with scoped access
+ path.replaceWith(
+ path.scope.buildUndefinedNode()
+ );
+ }
+ }
+ };
+ }
+
+ private static getImports(): string {
+ return `
+ // Add any necessary imports here
+ const { useState, useEffect, useRef, useMemo, useCallback } = React;
+ `;
+ }
+
+ private static getExports(): string {
+ return `
+ if (typeof Component === 'undefined') {
+ throw new Error('No component defined');
+ }
+ `;
+ }
+
+ private static stripTypeAnnotations(code: string): string {
+ // Basic TypeScript stripping - in a real implementation,
+ // you might want to use a proper TS transformer
+ return code
+ .replace(/:\s*[A-Za-z<>[\]]+/g, '')
+ .replace(/<[A-Za-z,\s]+>/g, '');
+ }
+
+ private static enhanceError(error: Error): Error {
+ // Enhance error messages for better debugging
+ if (error.message.includes('Component')) {
+ return new Error(`Component Error: ${error.message}`);
+ }
+ if (error.message.includes('React')) {
+ return new Error(`React Error: ${error.message}`);
+ }
+ return error;
+ }
+
+ // Utility method for checking if code is TypeScript
+ static isTypeScript(code: string): boolean {
+ return /:\s*[A-Za-z]+/.test(code) || /<[A-Za-z,\s]+>/.test(code);
+ }
+}
+
+// Example usage:
+/*
+const code = `
+ const [count, setCount] = useState(0);
+ return (
+
+ );
+`;
+
+const { component: Counter } = await ComponentTransformer.transform(code, {
+ scope: {
+ // Additional scope variables
+ customVar: 'value'
+ },
+ isInline: true
+});
+*/
\ No newline at end of file
diff --git a/src/core/useMarketData.tsx b/src/core/useMarketData.tsx
new file mode 100644
index 0000000..e085d33
--- /dev/null
+++ b/src/core/useMarketData.tsx
@@ -0,0 +1,98 @@
+// src/hooks/useMarketData.tsx
+import { useState, useEffect } from 'react';
+import { TFile } from 'obsidian';
+import { StorageManager } from '../core/storage';
+import { MarketDataService } from 'src/services/marketDataService';
+import { MarketData, MarketDataCache } from '../services/marketDataService';
+
+interface UseMarketDataResult {
+ data: MarketData[];
+ loading: boolean;
+ error: Error | null;
+}
+export function useMarketData(
+ symbol: string,
+ interval: string,
+ range: string,
+ storage: StorageManager,
+ noteFile: TFile
+) {
+ const [data, setData] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ const fetchData = async () => {
+ try {
+ setLoading(true);
+ const marketData = await storage.getMarketData(
+ symbol,
+ interval,
+ range,
+ noteFile
+ );
+ setData(marketData);
+ } catch (err) {
+ setError(err instanceof Error ? err : new Error('Unknown error'));
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ fetchData();
+ }, [symbol, interval, range, noteFile, storage]);
+
+ return { data, loading, error };
+}
+export function createMarketDataHook(storage: StorageManager, noteFile: TFile) {
+ return function useMarketData(
+ symbol: string,
+ interval: string,
+ range: string
+ ): UseMarketDataResult {
+ const [data, setData] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ const fetchData = async () => {
+ try {
+ setLoading(true);
+ const cacheKey = `market-data-${symbol}-${interval}-${range}`;
+
+ // Try to get from storage first
+ const cached = await storage.get(
+ cacheKey,
+ null,
+ noteFile
+ );
+
+ if (cached && Date.now() - cached.timestamp < 24 * 60 * 60 * 1000) {
+ setData(cached.data);
+ return;
+ }
+
+ // Fetch fresh data
+ const {data:freshData} = await MarketDataService.fetchHistoricalData(symbol);
+
+ // Cache the new data
+ await storage.set(
+ cacheKey,
+ { data: freshData, timestamp: Date.now() },
+ noteFile
+ );
+
+ setData(freshData);
+ } catch (err) {
+ setError(err instanceof Error ? err : new Error('Unknown error'));
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ fetchData();
+ }, [symbol, interval, range]);
+
+ return { data, loading, error };
+ };
+}
\ No newline at end of file
diff --git a/src/hooks/useStorage.ts b/src/hooks/useStorage.ts
new file mode 100644
index 0000000..81da85f
--- /dev/null
+++ b/src/hooks/useStorage.ts
@@ -0,0 +1,27 @@
+// src/hooks/useStorage.tsx
+import { useState, useEffect } from 'react';
+import { TFile } from 'obsidian';
+import { StorageManager } from '../core/storage';
+
+export function useStorage(
+ key: string,
+ defaultValue: T,
+ storage: StorageManager,
+ noteFile: TFile
+): [T, (value: T | ((prev: T) => T)) => Promise] {
+ const [value, setValue] = useState(defaultValue);
+
+ // Load initial value
+ useEffect(() => {
+ storage.get(key, defaultValue, noteFile).then(setValue);
+ }, [key, defaultValue, noteFile]);
+
+ // Update function
+ const updateValue = async (newValue: T | ((prev: T) => T)) => {
+ const actualNewValue = newValue instanceof Function ? newValue(value) : newValue;
+ setValue(actualNewValue);
+ await storage.set(key, actualNewValue, noteFile);
+ };
+
+ return [value, updateValue];
+}
\ No newline at end of file
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
new file mode 100644
index 0000000..0b988ed
--- /dev/null
+++ b/src/lib/utils.ts
@@ -0,0 +1,7 @@
+//src/lib/util.ts
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+ return twMerge(clsx(inputs))
+}
\ No newline at end of file
diff --git a/src/services/OrderBlockAnalysis.ts b/src/services/OrderBlockAnalysis.ts
new file mode 100644
index 0000000..5904362
--- /dev/null
+++ b/src/services/OrderBlockAnalysis.ts
@@ -0,0 +1,793 @@
+// src/services/OrderBlockAnalysis.ts
+import { TFile } from 'obsidian';
+import { MarketDataService, MarketData } from './marketDataService';
+import { MarketDataStorage } from './marketDataStorage';
+
+interface SwingPoint {
+ time: number;
+ price: number;
+ type: 'high' | 'low';
+ index: number;
+}
+interface TrendLeg {
+ startIndex: number;
+ endIndex: number;
+ startTime: number;
+ endTime: number;
+ direction: 'up' | 'down' | 'sideways';
+ strength: number;
+ startPrice: number;
+ endPrice: number;
+ swingPoints: SwingPoint[];
+}
+interface OrderBlock {
+ id: string;
+ type: 'bullish' | 'bearish';
+ startTime: number;
+ endTime: number;
+ highPrice: number;
+ lowPrice: number;
+ volume: number;
+ impulseMagnitude: number;
+ priceValueGap: number;
+ validationMetrics: {
+ trendAlignment: boolean;
+ hasBreakOfStructure: boolean;
+ gapQuality: number; // 0-1 score
+ impulseStrength: number; // Relative to average movement
+ };
+}
+
+interface AnalysisResult {
+ symbol: string;
+ timeframe: string;
+ analysisTime: number;
+ marketHours: {
+ start: number;
+ end: number;
+ };
+ marketData: MarketData[]; // Add this
+ trendLegs: TrendLeg[]; // Add this
+ trend: {
+ direction: 'up' | 'down' | 'none';
+ strength: number;
+ swingPoints: SwingPoint[];
+ };
+ orderBlocks: OrderBlock[];
+}
+
+export class OrderBlockAnalysisService {
+ private static readonly MARKET_HOURS = {
+ start: { hour: 9, minute: 30 },
+ end: { hour: 16, minute: 0 }
+ };
+// Analysis specific params
+ private static readonly ANALYSIS_PARAMS = {
+ minSwingPoints: 4,
+ lookbackPeriods: 20,
+ minImpulseStrength: 1.5,
+ minGapSize: 0.1, // 10% of average candle size
+ trendStrengthThreshold: 0.6
+ };
+ private static readonly TREND_PARAMS = {
+ minSwingPoints: 2, // Reduced minimum swing points
+ trendThreshold: 0.4, // Lowered threshold
+ minMovementSize: 0.1, // Minimum % move
+ swingPointConfirmation: 1, // Candles to confirm swing
+ momentumThreshold: 0.6, // New: Momentum strength threshold
+ priceChangeThreshold: 0.001 // New: Minimum price change (0.1%)
+ };
+ constructor(
+ private storage: MarketDataStorage,
+ private marketDataService: MarketDataService
+ ) {}
+
+ /**
+ * Main analysis function for a given symbol and timeframe
+ */
+ async analyzeOrderBlocks(
+ symbol: string,
+ timeframe: string,
+ noteFile: TFile
+ ): Promise {
+ try{
+ const today = new Date();
+ const startTime = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ today.getDate()-1,
+ OrderBlockAnalysisService.MARKET_HOURS.start.hour,
+ OrderBlockAnalysisService.MARKET_HOURS.start.minute
+ ).getTime();
+
+ const endTime = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ today.getDate()-1,
+ OrderBlockAnalysisService.MARKET_HOURS.end.hour,
+ OrderBlockAnalysisService.MARKET_HOURS.end.minute
+ ).getTime();
+
+ const config = {
+ interval: timeframe as any,
+ startTime,
+ endTime
+ };
+
+ // Use the marketDataService instance for fetching
+ const data = await MarketDataService.getMarketData(symbol, config, this.storage);
+
+ // Apply market hours filter
+ const marketHoursData = this.filterMarketHours(data);
+
+ const trend = this.analyzeTrend(marketHoursData);
+ const orderBlocks = this.findOrderBlocks(marketHoursData, trend);
+
+ return {
+ symbol,
+ timeframe,
+ analysisTime: Date.now(),
+ marketHours: {
+ start: startTime,
+ end: endTime
+ },
+ marketData: marketHoursData,
+ trendLegs: this.analyzeTrendLegs(marketHoursData),
+ trend,
+ orderBlocks
+ };
+ } catch (error) {
+ console.error('Error analyzing order blocks:', error);
+ throw error;
+ }
+ }
+
+ /**
+ * Filter data for market hours only
+ */
+ private filterMarketHours(data: MarketData[]): MarketData[] {
+ return data.filter(candle => {
+ const date = new Date(candle.time);
+ const hours = date.getHours();
+ const minutes = date.getMinutes();
+
+ if (hours < OrderBlockAnalysisService.MARKET_HOURS.start.hour ||
+ hours > OrderBlockAnalysisService.MARKET_HOURS.end.hour) return false;
+
+ if (hours === OrderBlockAnalysisService.MARKET_HOURS.start.hour &&
+ minutes < OrderBlockAnalysisService.MARKET_HOURS.start.minute) return false;
+
+ if (hours === OrderBlockAnalysisService.MARKET_HOURS.end.hour &&
+ minutes >= OrderBlockAnalysisService.MARKET_HOURS.end.minute) return false;
+
+ return true;
+ });
+ }
+
+/**
+ * Enhanced trend analysis that considers both structure and momentum
+ */
+private analyzeTrend(data: MarketData[]): {
+ direction: 'up' | 'down' | 'none';
+ strength: number;
+ swingPoints: SwingPoint[];
+} {
+ if (data.length < 10) return { direction: 'none', strength: 0, swingPoints: [] };
+
+ const atr = this.calculateATR(data, 14);
+ const swingPoints = this.findSignificantSwings(data, atr);
+
+ // Calculate overall momentum
+ const momentum = this.calculateMomentum(data);
+
+ // Calculate price movement
+ const priceChange = (data[data.length - 1].close - data[0].close) / data[0].close;
+ const absolutePriceChange = Math.abs(priceChange);
+
+ // Only proceed with detailed analysis if we have significant price movement
+ if (absolutePriceChange < OrderBlockAnalysisService.TREND_PARAMS.priceChangeThreshold) {
+ return { direction: 'none', strength: 0, swingPoints };
+ }
+
+ // Get structural analysis
+ const structure = this.analyzeTrendStructure(swingPoints, atr);
+
+ // Combine structural and momentum analysis
+ const direction = this.determineOverallTrend(structure, momentum, priceChange);
+ const strength = this.calculateOverallStrength(structure.strength, momentum.strength);
+
+ return {
+ direction,
+ strength,
+ swingPoints
+ };
+}
+
+ /**
+ * Calculate Average True Range
+ */
+private calculateATR(data: MarketData[], period: number): number {
+ if (data.length < period) return 0;
+
+ let tr = [];
+ for (let i = 1; i < data.length; i++) {
+ const high = data[i].high;
+ const low = data[i].low;
+ const prevClose = data[i-1].close;
+
+ tr.push(Math.max(
+ high - low,
+ Math.abs(high - prevClose),
+ Math.abs(low - prevClose)
+ ));
+ }
+
+ // Calculate simple moving average of TR
+ const atr = tr.slice(-period).reduce((sum, val) => sum + val, 0) / period;
+ return atr;
+}
+/**
+ * Calculate price momentum
+ */
+private calculateMomentum(data: MarketData[]): { direction: 'up' | 'down'; strength: number } {
+ const closes = data.map(d => d.close);
+ let upMoves = 0;
+ let downMoves = 0;
+
+ // Count consecutive moves
+ for (let i = 1; i < closes.length; i++) {
+ if (closes[i] > closes[i - 1]) upMoves++;
+ if (closes[i] < closes[i - 1]) downMoves++;
+ }
+
+ const totalMoves = upMoves + downMoves;
+ const upStrength = upMoves / totalMoves;
+ const downStrength = downMoves / totalMoves;
+
+ return {
+ direction: upStrength > downStrength ? 'up' : 'down',
+ strength: Math.max(upStrength, downStrength)
+ };
+}
+
+/**
+ * Determine overall trend combining structure and momentum
+ */
+private determineOverallTrend(
+ structure: { direction: 'up' | 'down' | 'none'; strength: number },
+ momentum: { direction: 'up' | 'down'; strength: number },
+ priceChange: number
+): 'up' | 'down' | 'none' {
+ // Strong momentum overrides structure
+ if (momentum.strength > OrderBlockAnalysisService.TREND_PARAMS.momentumThreshold) {
+ return momentum.direction;
+ }
+
+ // Strong structure with confirming price change
+ if (structure.direction !== 'none' &&
+ Math.sign(priceChange) === (structure.direction === 'up' ? 1 : -1)) {
+ return structure.direction;
+ }
+
+ // Default to momentum direction if price change confirms it
+ if (Math.sign(priceChange) === (momentum.direction === 'up' ? 1 : -1)) {
+ return momentum.direction;
+ }
+
+ return 'none';
+}
+
+/**
+ * Calculate overall trend strength
+ */
+private calculateOverallStrength(structureStrength: number, momentumStrength: number): number {
+ return (structureStrength * 0.6 + momentumStrength * 0.4);
+}
+/**
+ * Find significant swing points using ATR for context
+ */
+private findSignificantSwings(data: MarketData[], atr: number): SwingPoint[] {
+ const swingPoints: SwingPoint[] = [];
+ const minMove = atr * 0.3; // Reduced from 0.5 to catch more potential swings
+
+ for (let i = 2; i < data.length - 2; i++) {
+ const current = data[i];
+ const before = data.slice(i - 2, i);
+ const after = data.slice(i + 1, i + 3);
+
+ // Check for swing high with relaxed conditions
+ if (before.every(c => c.high <= current.high) &&
+ after[0].high < current.high) {
+ swingPoints.push({
+ type: 'high',
+ price: current.high,
+ time: current.time,
+ index: i
+ });
+ }
+
+ // Check for swing low with relaxed conditions
+ if (before.every(c => c.low >= current.low) &&
+ after[0].low > current.low) {
+ swingPoints.push({
+ type: 'low',
+ price: current.low,
+ time: current.time,
+ index: i
+ });
+ }
+ }
+
+ return swingPoints;
+}
+
+/**
+ * Analyze trend structure using swing points
+ */
+private analyzeTrendStructure(
+ swingPoints: SwingPoint[],
+ atr: number
+): { direction: 'up' | 'down' | 'none'; strength: number; } {
+ const highs = swingPoints.filter(p => p.type === 'high')
+ .sort((a, b) => a.time - b.time);
+ const lows = swingPoints.filter(p => p.type === 'low')
+ .sort((a, b) => a.time - b.time);
+
+ if (highs.length < 2 || lows.length < 2) {
+ return { direction: 'none', strength: 0 };
+ }
+
+ // Calculate trend metrics
+ const hhSequence = this.calculateSequenceStrength(highs, 'up', atr);
+ const lhSequence = this.calculateSequenceStrength(highs, 'down', atr);
+ const hlSequence = this.calculateSequenceStrength(lows, 'up', atr);
+ const llSequence = this.calculateSequenceStrength(lows, 'down', atr);
+
+ // Determine trend
+ const upStrength = (hhSequence + hlSequence) / 2;
+ const downStrength = (lhSequence + llSequence) / 2;
+
+ if (upStrength > OrderBlockAnalysisService.TREND_PARAMS.trendThreshold &&
+ upStrength > downStrength) {
+ return {
+ direction: 'up',
+ strength: upStrength
+ };
+ }
+
+ if (downStrength > OrderBlockAnalysisService.TREND_PARAMS.trendThreshold &&
+ downStrength > upStrength) {
+ return {
+ direction: 'down',
+ strength: downStrength
+ };
+ }
+
+ return { direction: 'none', strength: 0 };
+}
+private analyzeTrendLegs(data: MarketData[]): TrendLeg[] {
+ const trendLegs: TrendLeg[] = [];
+ const atr = this.calculateATR(data, 14);
+ let currentLegStart = 0;
+
+ // Minimum number of candles to consider a valid trend leg
+ const MIN_LEG_LENGTH = 5;
+
+ // Loop through data to identify trend changes
+ for (let i = MIN_LEG_LENGTH; i < data.length - MIN_LEG_LENGTH; i++) {
+ const currentSegment = data.slice(currentLegStart, i + 1);
+ const nextSegment = data.slice(i - MIN_LEG_LENGTH, i + MIN_LEG_LENGTH);
+
+ // Check for trend change
+ if (this.isTrendChange(currentSegment, nextSegment, atr)) {
+ // Add completed trend leg
+ if (i - currentLegStart >= MIN_LEG_LENGTH) {
+ const legData = data.slice(currentLegStart, i);
+ const trendLeg = this.analyzeSingleTrendLeg(legData, currentLegStart, i);
+ trendLegs.push(trendLeg);
+ }
+ currentLegStart = i;
+ }
+ }
+
+ // Add final trend leg
+ if (data.length - currentLegStart >= MIN_LEG_LENGTH) {
+ const finalLegData = data.slice(currentLegStart);
+ const finalTrendLeg = this.analyzeSingleTrendLeg(
+ finalLegData,
+ currentLegStart,
+ data.length - 1
+ );
+ trendLegs.push(finalTrendLeg);
+ }
+
+ return trendLegs;
+}
+
+private isTrendChange(
+ currentSegment: MarketData[],
+ nextSegment: MarketData[],
+ atr: number
+): boolean {
+ const currentDirection = this.determineTrendDirection(currentSegment);
+ const nextDirection = this.determineTrendDirection(nextSegment);
+
+ // Check for direction change
+ if (currentDirection !== nextDirection) {
+ // Verify change is significant (> 1 ATR)
+ const priceChange = Math.abs(
+ nextSegment[nextSegment.length - 1].close - nextSegment[0].close
+ );
+ return priceChange > atr;
+ }
+
+ return false;
+}
+
+private analyzeSingleTrendLeg(
+ data: MarketData[],
+ startIndex: number,
+ endIndex: number
+): TrendLeg {
+ const swingPoints = this.findSignificantSwings(data, this.calculateATR(data, 14));
+ const priceChange = (data[data.length - 1].close - data[0].close) / data[0].close;
+ const momentum = this.calculateMomentum(data);
+
+ // Determine trend direction
+ let direction: 'up' | 'down' | 'sideways';
+ if (Math.abs(priceChange) < OrderBlockAnalysisService.TREND_PARAMS.priceChangeThreshold) {
+ direction = 'sideways';
+ } else {
+ direction = priceChange > 0 ? 'up' : 'down';
+ }
+
+ // Calculate trend strength based on:
+ // 1. Price change magnitude
+ // 2. Momentum consistency
+ // 3. Swing point alignment
+ const priceStrength = Math.min(Math.abs(priceChange) * 10, 1); // Scale price change
+ const momentumStrength = momentum.strength;
+ const swingStrength = this.calculateSwingAlignment(swingPoints, direction);
+
+ const strength = (
+ priceStrength * 0.4 +
+ momentumStrength * 0.4 +
+ swingStrength * 0.2
+ ) * 100; // Convert to percentage
+
+ return {
+ startIndex,
+ endIndex,
+ startTime: data[0].time,
+ endTime: data[data.length - 1].time,
+ direction,
+ strength,
+ startPrice: data[0].close,
+ endPrice: data[data.length - 1].close,
+ swingPoints
+ };
+}
+
+private calculateSwingAlignment(
+ swingPoints: SwingPoint[],
+ direction: 'up' | 'down' | 'sideways'
+): number {
+ if (direction === 'sideways' || swingPoints.length < 2) return 0;
+
+ let aligned = 0;
+ let total = 0;
+
+ for (let i = 1; i < swingPoints.length; i++) {
+ if (direction === 'up') {
+ if (swingPoints[i].price > swingPoints[i - 1].price) aligned++;
+ } else {
+ if (swingPoints[i].price < swingPoints[i - 1].price) aligned++;
+ }
+ total++;
+ }
+
+ return total > 0 ? aligned / total : 0;
+}
+
+private determineTrendDirection(data: MarketData[]): 'up' | 'down' | 'sideways' {
+ const priceChange = (data[data.length - 1].close - data[0].close) / data[0].close;
+
+ if (Math.abs(priceChange) < OrderBlockAnalysisService.TREND_PARAMS.priceChangeThreshold) {
+ return 'sideways';
+ }
+ return priceChange > 0 ? 'up' : 'down';
+}
+/**
+ * Calculate sequence strength relative to ATR
+ */
+private calculateSequenceStrength(
+ points: SwingPoint[],
+ direction: 'up' | 'down',
+ atr: number
+): number {
+ if (points.length < 2) return 0;
+
+ let validMoves = 0;
+ let totalMoves = 0;
+
+ for (let i = 1; i < points.length; i++) {
+ const move = direction === 'up'
+ ? points[i].price - points[i-1].price
+ : points[i-1].price - points[i].price;
+
+ if (move > 0 && Math.abs(move) > atr * 0.5) {
+ validMoves++;
+ }
+ totalMoves++;
+ }
+
+ return totalMoves > 0 ? validMoves / totalMoves : 0;
+}
+
+ /**
+ * Calculate trend strength (0-1)
+ */
+ private calculateTrendStrength(
+ points: SwingPoint[],
+ direction: 'up' | 'down'
+ ): number {
+ if (points.length < 2) return 0;
+
+ let increasing = 0;
+ let total = 0;
+
+ for (let i = 1; i < points.length; i++) {
+ const current = points[i].price;
+ const previous = points[i - 1].price;
+
+ if (direction === 'up' && current > previous) increasing++;
+ if (direction === 'down' && current < previous) increasing++;
+ total++;
+ }
+
+ return total > 0 ? increasing / total : 0;
+ }
+ /**
+ * Find order blocks
+ */
+ private findOrderBlocks(
+ data: MarketData[],
+ trend: { direction: 'up' | 'down' | 'none'; strength: number; }
+ ): OrderBlock[] {
+ const orderBlocks: OrderBlock[] = [];
+
+ // Only proceed if we have a clear trend
+ if (trend.direction === 'none' || trend.strength < OrderBlockAnalysisService.ANALYSIS_PARAMS.trendStrengthThreshold) {
+ return orderBlocks;
+ }
+
+ // Use a sliding window of 7 candles (3 before, current, 3 after)
+ for (let i = 3; i < data.length - 3; i++) {
+ const window = {
+ before: data.slice(i - 3, i),
+ current: data[i],
+ after: data.slice(i + 1, i + 4)
+ };
+
+ // Check for potential order block
+ const orderBlock = this.validateOrderBlock(window, trend.direction);
+ if (orderBlock) {
+ orderBlocks.push(orderBlock);
+ }
+ }
+
+ return this.filterOverlappingBlocks(orderBlocks);
+ }
+
+ /**
+ * Validate potential order block
+ */
+ private validateOrderBlock(
+ window: {
+ before: MarketData[];
+ current: MarketData;
+ after: MarketData[];
+ },
+ trendDirection: 'up' | 'down'
+ ): OrderBlock | null {
+ const { before, current, after } = window;
+
+ // Check for bullish order block in uptrend
+ if (trendDirection === 'up') {
+ const isBearishCandle = current.close < current.open;
+ const hasImpulsiveMove = this.hasImpulsiveMove(after, 'up');
+ const pvg = this.calculatePriceValueGap([...before, current, ...after]);
+
+ if (isBearishCandle && hasImpulsiveMove && pvg > OrderBlockAnalysisService.ANALYSIS_PARAMS.minGapSize) {
+ return {
+ id: `OB_${current.time}`,
+ type: 'bullish',
+ startTime: current.time,
+ endTime: after[0].time,
+ highPrice: current.high,
+ lowPrice: current.low,
+ volume: current.volume,
+ impulseMagnitude: this.calculateImpulseMagnitude([...before, current, ...after]),
+ priceValueGap: pvg,
+ validationMetrics: {
+ trendAlignment: true,
+ hasBreakOfStructure: this.hasBreakOfStructure([...before, current, ...after], 'up'),
+ gapQuality: this.calculateGapQuality(pvg, current),
+ impulseStrength: this.calculateImpulseStrength(after, before)
+ }
+ };
+ }
+ }
+
+ // Check for bearish order block in downtrend
+ if (trendDirection === 'down') {
+ const isBullishCandle = current.close > current.open;
+ const hasImpulsiveMove = this.hasImpulsiveMove(after, 'down');
+ const pvg = this.calculatePriceValueGap([...before, current, ...after]);
+
+ if (isBullishCandle && hasImpulsiveMove && pvg > OrderBlockAnalysisService.ANALYSIS_PARAMS.minGapSize) {
+ return {
+ id: `OB_${current.time}`,
+ type: 'bearish',
+ startTime: current.time,
+ endTime: after[0].time,
+ highPrice: current.high,
+ lowPrice: current.low,
+ volume: current.volume,
+ impulseMagnitude: this.calculateImpulseMagnitude([...before, current, ...after]),
+ priceValueGap: pvg,
+ validationMetrics: {
+ trendAlignment: true,
+ hasBreakOfStructure: this.hasBreakOfStructure([...before, current, ...after], 'down'),
+ gapQuality: this.calculateGapQuality(pvg, current),
+ impulseStrength: this.calculateImpulseStrength(after, before)
+ }
+ };
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Calculate price value gap
+ */
+ private calculatePriceValueGap(candles: MarketData[]): number {
+ let maxGap = 0;
+
+ for (let i = 1; i < candles.length - 1; i++) {
+ const current = candles[i];
+ const next = candles[i + 1];
+
+ // Check for gap between candles
+ if (next.low > current.high) {
+ maxGap = Math.max(maxGap, next.low - current.high);
+ }
+ if (next.high < current.low) {
+ maxGap = Math.max(maxGap, current.low - next.high);
+ }
+ }
+
+ return maxGap;
+ }
+
+ /**
+ * Check for impulsive move
+ */
+ private hasImpulsiveMove(candles: MarketData[], direction: 'up' | 'down'): boolean {
+ const moves = candles.map(c => Math.abs(c.close - c.open));
+ const avgMove = moves.reduce((sum, move) => sum + move, 0) / moves.length;
+
+ if (direction === 'up') {
+ return candles[0].close > candles[0].open &&
+ avgMove > OrderBlockAnalysisService.ANALYSIS_PARAMS.minImpulseStrength;
+ } else {
+ return candles[0].close < candles[0].open &&
+ avgMove > OrderBlockAnalysisService.ANALYSIS_PARAMS.minImpulseStrength;
+ }
+ }
+
+ /**
+ * Calculate impulse magnitude
+ */
+ private calculateImpulseMagnitude(candles: MarketData[]): number {
+ const moves = candles.map(c => ({
+ move: Math.abs(c.close - c.open),
+ volume: c.volume
+ }));
+
+ // Volume-weighted average move
+ const weightedMoves = moves.map(m => m.move * (m.volume / Math.max(...moves.map(x => x.volume))));
+ return weightedMoves.reduce((sum, move) => sum + move, 0) / weightedMoves.length;
+ }
+
+ /**
+ * Calculate gap quality (0-1)
+ */
+ private calculateGapQuality(gap: number, candle: MarketData): number {
+ const candleSize = Math.abs(candle.high - candle.low);
+ return Math.min(gap / candleSize, 1);
+ }
+
+ /**
+ * Calculate impulse strength
+ */
+ private calculateImpulseStrength(after: MarketData[], before: MarketData[]): number {
+ const afterMoves = after.map(c => Math.abs(c.close - c.open));
+ const beforeMoves = before.map(c => Math.abs(c.close - c.open));
+
+ const avgAfter = afterMoves.reduce((sum, move) => sum + move, 0) / afterMoves.length;
+ const avgBefore = beforeMoves.reduce((sum, move) => sum + move, 0) / beforeMoves.length;
+
+ return avgAfter / avgBefore;
+ }
+
+ /**
+ * Check for break of structure
+ */
+ private hasBreakOfStructure(candles: MarketData[], direction: 'up' | 'down'): boolean {
+ const middle = Math.floor(candles.length / 2);
+ const before = candles.slice(0, middle);
+ const after = candles.slice(middle);
+
+ if (direction === 'up') {
+ const beforeHigh = Math.max(...before.map(c => c.high));
+ const afterHigh = Math.max(...after.map(c => c.high));
+ return afterHigh > beforeHigh;
+ } else {
+ const beforeLow = Math.min(...before.map(c => c.low));
+ const afterLow = Math.min(...after.map(c => c.low));
+ return afterLow < beforeLow;
+ }
+ }
+
+ /**
+ * Filter overlapping order blocks
+ */
+ private filterOverlappingBlocks(blocks: OrderBlock[]): OrderBlock[] {
+ return blocks.filter((block, index) => {
+ // Check if this block overlaps with any stronger blocks
+ const hasStrongerOverlap = blocks.some((otherBlock, otherIndex) => {
+ if (index === otherIndex) return false;
+
+ const timeOverlap = block.startTime <= otherBlock.endTime &&
+ block.endTime >= otherBlock.startTime;
+
+ const priceOverlap = block.lowPrice <= otherBlock.highPrice &&
+ block.highPrice >= otherBlock.lowPrice;
+
+ return timeOverlap && priceOverlap &&
+ otherBlock.validationMetrics.impulseStrength >
+ block.validationMetrics.impulseStrength;
+ });
+
+ return !hasStrongerOverlap;
+ });
+ }
+
+ private getTodayMarketOpen(): number {
+ const now = new Date();
+ return new Date(
+ now.getFullYear(),
+ now.getMonth(),
+ now.getDate(),
+ OrderBlockAnalysisService.MARKET_HOURS.start.hour,
+ OrderBlockAnalysisService.MARKET_HOURS.start.minute
+ ).getTime();
+ }
+
+ private getTodayMarketClose(): number {
+ const now = new Date();
+ return new Date(
+ now.getFullYear(),
+ now.getMonth(),
+ now.getDate(),
+ OrderBlockAnalysisService.MARKET_HOURS.end.hour,
+ OrderBlockAnalysisService.MARKET_HOURS.end.minute
+ ).getTime();
+ }
+
+
+}
+
+export type { AnalysisResult, OrderBlock, SwingPoint };
\ No newline at end of file
diff --git a/src/services/marketDataService.ts b/src/services/marketDataService.ts
new file mode 100644
index 0000000..06c0a5f
--- /dev/null
+++ b/src/services/marketDataService.ts
@@ -0,0 +1,459 @@
+// src/services/marketDataService.ts
+import { error, time } from "console";
+import { MarketDataStorage } from "./marketDataStorage";
+import { TFile } from "obsidian";
+import dotenv from 'dotenv';
+// Initialize dotenv
+dotenv.config();
+
+// Create a config object to manage environment variables
+const config = {
+ primaryApiKey: process.env.ALPHA_VANTAGE_PRIMARY_KEY,
+ secondaryApiKey: process.env.ALPHA_VANTAGE_SECONDARY_KEY,
+ cacheDuration: parseInt(process.env.MARKET_DATA_CACHE_DURATION || '86400000'),
+ timezone: process.env.TIMEZONE || 'US/Eastern',
+
+ // Validate environment variables
+ validate() {
+ if (!this.primaryApiKey) {
+ throw new Error('ALPHA_VANTAGE_PRIMARY_KEY is not set in environment variables');
+ }
+ if (!this.secondaryApiKey) {
+ throw new Error('ALPHA_VANTAGE_SECONDARY_KEY is not set in environment variables');
+ }
+ }
+};
+
+
+export interface MarketData {
+ time: number;
+ open: number;
+ high: number;
+ low: number;
+ close: number;
+ volume: number;
+ sma?: number; // Simple Moving Average
+ ema?: number; // Exponential Moving Average
+ rsi?: number; // Relative Strength Index
+}
+export interface MarketDataCache {
+ data: MarketData[];
+ timestamp: number;
+}
+export interface MarketHours {
+ start: number; // 4:00 AM ET
+ end: number; // 19:59 PM ET
+ timeZone: string; // 'America/New_York'
+}
+export type IntervalType = '1min' | '5min' | '15min' | '30min' | '60min' | 'daily';
+
+export interface TimeframeConfig {
+ interval: IntervalType;
+ startTime: number;
+ endTime: number;
+}
+
+export interface CacheEntry {
+ data: MarketData[];
+ timestamp: number;
+ interval: IntervalType;
+ startTime: number;
+ endTime: number;
+ timezone:string;
+}
+
+export interface CacheMetadata {
+ [symbol: string]: {
+ [interval in IntervalType]?: CacheEntry[];
+ };
+}
+export class MarketDataService {
+ static async fetchHistoricalData(
+ symbol: string,
+ outputsize: 'full' | 'compact' = 'full'
+ ): Promise<{data:MarketData[],timezone: string}> {
+ // Validate environment variables
+ config.validate();
+
+ const url = `https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=${symbol}&outputsize=${outputsize}&apikey=${config.primaryApiKey}`;
+
+ try {
+ const response = await fetch(url);
+ const data = await response.json();
+
+ // Check for API errors
+ if (data['Error Message']) {
+ throw new Error(data['Error Message']);
+ }
+
+ const timezone = data['Meta Data']['6. Time Zone'];
+ const timeSeries = data['Time Series (Daily)'];
+
+ const marketData= Object.entries(timeSeries).map(([date, values]: [string, any]) => ({
+ time: new Date(date).getTime(),
+ open: parseFloat(values['1. open']),
+ high: parseFloat(values['2. high']),
+ low: parseFloat(values['3. low']),
+ close: parseFloat(values['4. close']),
+ volume: parseInt(values['5. volume'])
+ })).reverse();
+ return{data:marketData,timezone}
+ } catch (error) {
+ console.error('Error fetching historical data:', error);
+ throw error;
+ }
+ }
+
+ static async fetchIntraday(
+ symbol: string,
+ interval: '1min' | '5min' | '15min' | '30min' | '60min' = '5min'
+ ): Promise<{data: MarketData[], timezone: string }> {
+ // Validate environment variables
+ config.validate();
+
+ const url = `https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol=${symbol}&interval=${interval}&outputsize=full&apikey=${config.secondaryApiKey}`;
+
+ try {
+ const response = await fetch(url);
+ const data = await response.json();
+
+ // Check for rate limit message
+ /* if (data.Information && data.Information.includes('rate limit')) {
+ throw new Error('API rate limit reached. Please try again in a minute.');
+ }*/
+ // Log full response to see structure
+ console.log('Alpha Vantage Response:', data);
+
+ // Method 1: Log all top-level keys
+ console.log('Top level keys:', Object.keys(data));
+ const timezone = data['Meta Data']['5. Time Zone'];
+ const timeSeriesKey = `Time Series (${interval})`;
+ const timeSeries = data[timeSeriesKey];
+
+ if (!timeSeries) {
+ throw new Error('No data returned from API. You may have exceeded the daily limit.');
+ }
+
+ const marketData= Object.entries(timeSeries).map(([date, values]: [string, any]) => ({
+ time: new Date(date).getTime(),
+ open: parseFloat(values['1. open']),
+ high: parseFloat(values['2. high']),
+ low: parseFloat(values['3. low']),
+ close: parseFloat(values['4. close']),
+ volume: parseInt(values['5. volume'])
+ })).reverse();
+
+ return { data: marketData, timezone}
+ } catch (error) {
+ console.error('Error fetching intraday data:', error);
+ throw error;
+ //For when we want to hide implementation details
+ //throw new Error('Unable to fetch intraday data. Please try again later.');
+ }
+ }
+ static readonly MARKET_HOURS: MarketHours = {
+ start: 4 * 60, // 4:00 AM in minutes
+ end: 20 * 60 - 1, // 19:59 PM in minutes
+ timeZone: config.timezone
+ };
+
+ // Add method for getting multiple timeframes in one call
+ static async fetchMultiTimeframe(
+ symbol: string,
+ timeframes: Array<'1min' | '5min' | '15min' | '30min' | '60min' | 'daily'>
+ ): Promise> {
+ try {
+ const results: Record = {};
+
+ await Promise.all(
+ timeframes.map(async (timeframe) => {
+ if (timeframe === 'daily') {
+ results[timeframe] = (await this.fetchHistoricalData(symbol)).data;
+ } else {
+ data:results[timeframe] = (await this.fetchIntraday(symbol, timeframe)).data;
+ }
+ })
+ );
+
+ return results;
+ } catch (error) {
+ console.error('Error fetching multiple timeframes:', error);
+ throw error;
+ }
+ }
+ private static INTERVALS_MINUTES = {
+ '1min': 1,
+ '5min': 5,
+ '15min': 15,
+ '30min': 30,
+ '60min': 60,
+ 'daily': 1440
+ };
+
+
+
+
+ private static adjustTimeEndRequest(timestamp: number): number {
+ const date = new Date(timestamp);
+ const day = date.getDay(); // 0 = Sunday, 6 = Saturday
+ const hours = date.getHours();
+ const minutes = date.getMinutes();
+
+ // If weekend, adjust to Friday
+ if (day === 1&&hours<9) {date.setDate(date.getDate() - 3);date.setHours(19, 59, 0, 0);} // Monday -> Friday
+ if (day === 0) {date.setDate(date.getDate() - 2); date.setHours(19, 59, 0, 0);} // Sunday -> Friday
+ if (day === 6) {date.setDate(date.getDate() - 1);date.setHours(19, 59, 0, 0);} // Saturday -> Friday
+
+ // Set to 16:00 (4 PM) ET if after market close
+ if (hours > 19|| hours<4 ) {
+ date.setHours(19, 59, 0, 0);
+ date.setDate(date.getDate() - hours<4?1:0);
+ }
+ return date.getTime();
+ }
+ private static doesCacheCover(cache: CacheEntry, request: TimeframeConfig): boolean {
+
+ // If cache's last data point is within 24 hours, consider it current
+ const adjustedEndTime = this.adjustTimeEndRequest(
+ cache.endTime +24*60*60*1000>= request.endTime ? cache.endTime : request.endTime
+ );
+ console.log('Request Time:', {
+
+ Time: new Date(adjustedEndTime).toLocaleString()
+ });
+ return cache.interval === request.interval &&
+ cache.startTime <= request.startTime &&
+ cache.endTime >= adjustedEndTime;
+ }
+ private static aggregateToHigherTimeframe(
+ data: MarketData[],
+ fromInterval: IntervalType,
+ toInterval: IntervalType
+ ): MarketData[] {
+ const fromMinutes = this.INTERVALS_MINUTES[fromInterval];
+ const toMinutes = this.INTERVALS_MINUTES[toInterval];
+ const barsPerPeriod = toMinutes / fromMinutes;
+
+ // Group data into higher timeframe periods
+ const groupedData: { [key: number]: MarketData[] } = {};
+ data.forEach(bar => {
+ const periodStart = Math.floor(bar.time / (toMinutes * 60 * 1000)) * (toMinutes * 60 * 1000);
+ if (!groupedData[periodStart]) {
+ groupedData[periodStart] = [];
+ }
+ groupedData[periodStart].push(bar);
+ });
+
+ // Aggregate each period
+ return Object.entries(groupedData)
+ .filter(([_, bars]) => bars.length >= barsPerPeriod * 0.7) // Require at least 70% of bars
+ .map(([time, bars]) => ({
+ time: parseInt(time),
+ open: bars[0].open,
+ high: Math.max(...bars.map(b => b.high)),
+ low: Math.min(...bars.map(b => b.low)),
+ close: bars[bars.length - 1].close,
+ volume: bars.reduce((sum, b) => sum + b.volume, 0)
+ }));
+ }
+
+ static addMarketTime(time: number, minutesToAdd: number): number {
+ let date = new Date(time);
+ let currentMinutes = date.getHours() * 60 + date.getMinutes();
+ let newMinutes = currentMinutes + minutesToAdd;
+
+ // If would exceed market close
+ if (newMinutes > this.MARKET_HOURS.end) {
+ // Move to next day at market open
+ date.setDate(date.getDate() + 1);
+ date.setHours(this.MARKET_HOURS.start/60, 0, 0, 0);
+
+ // If weekend, move to Monday
+ while (date.getDay() === 0 || date.getDay() === 6) {
+ date.setDate(date.getDate() + 1);
+ }
+ } else {
+ // Stay on same day, just update time
+ date.setHours(Math.floor(newMinutes / 60), newMinutes % 60, 0, 0);
+ }
+
+ return date.getTime();
+ }
+ static async getMarketData(
+ symbol: string,
+ config: TimeframeConfig,
+ storage: MarketDataStorage
+ ): Promise {
+ console.log('Request Config:', {
+ symbol,
+ interval: config.interval,
+ startTime: new Date(config.startTime).toLocaleString(),
+ endTime: new Date(config.endTime).toLocaleString()
+ });
+ try{
+ // Get all cache entries for this symbol/interval
+ const cacheEntries = await storage.getMarketData(symbol, config.interval);
+ console.log(`Found ${cacheEntries.length} cache entries`);
+ //console.log(`Checking cache for ${symbol} ${config.interval} data...`);
+const overlappingEntries = cacheEntries.filter(cache =>
+ // Entry ends after request starts AND entry starts before request ends
+ this.addMarketTime(cache.endTime,1) >= config.startTime && cache.startTime <= this.addMarketTime(config.endTime,1)
+ );
+ if (cacheEntries.length > 0) {
+ // Find overlapping cache entries
+
+
+ /*
+ console.log('Found overlapping cache entries:', overlappingEntries.map(cache => ({
+ startTime: new Date(cache.startTime).toLocaleString(),
+ endTime: new Date(cache.endTime).toLocaleString(),
+ dataPoints: cache.data.length
+ })));*/
+
+ // Check if any single cache entry covers our request
+ const coveringEntry =overlappingEntries.find(cache => this.doesCacheCover(cache, config))
+
+ if(coveringEntry) {
+ console.log('Found complete coverage in cache:', {
+ start: new Date(coveringEntry.startTime).toLocaleString(),
+ end: new Date(coveringEntry.endTime).toLocaleString()
+ });
+ return coveringEntry.data.filter(d =>
+ d.time >= config.startTime && d.time <= config.endTime
+ );
+ }
+ console.log(`Found ${overlappingEntries.length} overlapping entries but no complete coverage`);
+ }
+ console.log(`Cache miss for ${symbol} ${config.interval}, fetching from API...`);
+ // Check if we can build from lower timeframe data
+ const intervals = Object.keys(this.INTERVALS_MINUTES) as IntervalType[];
+ const lowerIntervals = intervals.filter(interval =>
+ this.canDeriveFromCache(interval, config.interval)
+ );
+
+ for (const interval of lowerIntervals) {
+ const lowerCacheEntries = await storage.getMarketData(symbol, interval);
+ // Find overlapping entries from lower timeframe
+ const overlappingEntries = lowerCacheEntries.filter(cache =>
+ cache.endTime >= config.startTime && cache.startTime <= config.endTime
+ );
+
+ // Check if we have complete coverage from lower timeframe
+ const hasFullCoverage = overlappingEntries.some(cache =>
+ this.doesCacheCover(cache, {
+ ...config,
+ interval: interval
+ })
+ );
+
+ if (hasFullCoverage) {
+ // Merge overlapping lower timeframe data
+ const mergedLowerData = overlappingEntries.reduce((acc, cache) =>
+ [...acc, ...cache.data], [] as MarketData[]
+ ).sort((a, b) => a.time - b.time);
+
+ // We can build the higher timeframe from this data
+ const aggregatedData = this.aggregateToHigherTimeframe(
+ mergedLowerData,
+ interval,
+ config.interval
+ );
+
+ // Cache the aggregated data
+ await storage.saveMarketData(symbol, {
+ data: aggregatedData,
+ timestamp: Date.now(),
+ interval: config.interval,
+ startTime: Math.min(...aggregatedData.map(d => d.time)),
+ endTime: Math.max(...aggregatedData.map(d => d.time)),
+ timezone: overlappingEntries[0].timezone, // Assume timezone is consistent
+ });
+
+ return aggregatedData.filter(d =>
+ d.time >= config.startTime && d.time <= config.endTime
+ );
+ }
+}
+ // If we can't build from cache, fetch new data
+ const {data, timezone} = await this.fetchAppropriateData(symbol, config);
+ let mergedData = data;
+ // If we have existing cached data, try to merge
+ if (cacheEntries.length > 0) {
+
+ if (overlappingEntries.length > 0) {
+ console.log('Attempting to merge with cached data');
+ mergedData = this.mergeMarketData(
+ overlappingEntries.reduce((acc, cache) => [...acc, ...cache.data], [] as MarketData[]),
+ data);
+
+ console.log('Merged with overlapping cached data:', {
+ overlappingCachePoints: overlappingEntries.reduce((sum, cache) => sum + cache.data.length, 0),
+ newPoints: data.length,
+ finalPoints: mergedData.length
+ });
+ }
+ }
+ const newStartTime = Math.min(...mergedData.map(d => d.time));
+ const newEndTime = Math.max(...mergedData.map(d => d.time));
+
+ // Check if this exact time range already exists in cache
+ const exactMatch = overlappingEntries.some(entry =>
+ Math.abs(entry.startTime - newStartTime) < 60000 && // Within 1 minute
+ Math.abs(entry.endTime - newEndTime) < 60000 && // Within 1 minute
+ entry.interval === config.interval
+ );
+
+if (!exactMatch) {
+ await storage.saveMarketData(symbol, {
+ data: mergedData,
+ timestamp: Date.now(),
+ interval: config.interval,
+ startTime: Math.min(...mergedData.map(d => d.time)),
+ endTime: Math.max(...mergedData.map(d => d.time)),
+ timezone
+ });
+ } else {
+ console.log('Skipping cache save - exact time range already exists');
+ }
+
+ return mergedData;
+ }
+ catch (error) {
+ console.error('Error in getMarketData:', error);
+ throw error; // Re-throw to handle in component
+}
+
+}
+ private static canDeriveFromCache(sourceInterval: IntervalType, targetInterval: IntervalType): boolean {
+ const sourceMinutes = this.INTERVALS_MINUTES[sourceInterval];
+ const targetMinutes = this.INTERVALS_MINUTES[targetInterval];
+ return sourceMinutes < targetMinutes && targetMinutes % sourceMinutes === 0;
+ }
+
+
+ private static async fetchAppropriateData(
+ symbol: string,
+ config: TimeframeConfig
+ ): Promise<{data:MarketData[], timezone: string}> {
+ if (config.interval === 'daily') {
+ return await this.fetchHistoricalData(symbol);
+ } else {
+ return await this.fetchIntraday(symbol, config.interval);
+ }
+ }
+ private static mergeMarketData(existingData: MarketData[], newData: MarketData[]): MarketData[] {
+ // Combine both arrays
+ const combined = [...existingData, ...newData];
+
+ // Sort by time
+ combined.sort((a, b) => a.time - b.time);
+
+ // Remove duplicates based on timestamp
+ return combined.filter((item, index, self) =>
+ index === 0 || item.time !== self[index - 1].time
+ );
+ }
+}
+
+
+
diff --git a/src/services/marketDataStorage.ts b/src/services/marketDataStorage.ts
new file mode 100644
index 0000000..54d60d1
--- /dev/null
+++ b/src/services/marketDataStorage.ts
@@ -0,0 +1,257 @@
+// src/services/marketDataStorage.ts
+import { TFile, Vault } from 'obsidian';
+import { MarketData, CacheEntry, CacheMetadata, IntervalType } from './marketDataService';
+
+export class MarketDataStorage {
+ private vault: Vault;
+ private noteFile: TFile;
+ private basePath: string;
+
+ constructor(vault: Vault, noteFile: TFile) {
+ this.vault = vault;
+ this.noteFile = noteFile;
+
+ // Determine the appropriate base path
+ this.basePath = this.determineBasePath();
+ }
+ private determineBasePath(): string {
+ // Check if note exists and is a markdown file
+ if (!this.noteFile || this.noteFile.extension !== 'md') {
+ throw new Error('Invalid note file');
+ }
+
+ // Get the parent folder path, defaulting to root if none
+ const parentPath = this.noteFile.parent?.path ?? '';
+
+ // If at root, store in vault root
+ if (!parentPath) {
+ return '.market-data';
+ }
+
+ // Store in parent folder
+ return `${parentPath}/.market-data`;
+ }
+ getBasePath(): string {
+ return this.basePath;
+ }
+ private async ensureDirectory(path: string) {
+ try {
+ if (!(await this.vault.adapter.exists(path))) {
+ await this.vault.adapter.mkdir(path);
+ }
+ } catch (error) {
+ console.error(`Failed to create directory ${path}:`, error);
+ throw new Error(`Failed to create market data directory: ${error.message}`);
+ }
+ }
+
+ async initialize() {
+ try {
+ // Ensure base directory exists
+ await this.ensureDirectory(this.basePath);
+
+ // Create metadata file if it doesn't exist
+ const metadataPath = `${this.basePath}/metadata.json`;
+ if (!(await this.vault.adapter.exists(metadataPath))) {
+ await this.vault.adapter.write(
+ metadataPath,
+ JSON.stringify({
+ created: Date.now(),
+ noteSource: this.noteFile.path
+ })
+ );
+ }
+
+ return true;
+ } catch (error) {
+ console.error('Failed to initialize market data storage:', error);
+ throw error;
+ }
+ }
+ // Helper method to get absolute path in vault
+ getAbsolutePath(relativePath: string): string {
+ return `${this.basePath}/${relativePath}`;
+}
+
+// Method to check if storage is properly initialized
+async isInitialized(): Promise {
+ try {
+ return await this.vault.adapter.exists(this.basePath);
+ } catch {
+ return false;
+ }
+}
+
+// Method to get storage location info
+async getStorageInfo(): Promise<{
+ basePath: string;
+ isInitialized: boolean;
+ parentFolder: string;
+ noteFile: string;
+}> {
+ return {
+ basePath: this.basePath,
+ isInitialized: await this.isInitialized(),
+ parentFolder: this.noteFile.parent?.path ?? '(root)',
+ noteFile: this.noteFile.path
+ };
+}
+ private getSymbolPath(symbol: string) {
+ return `${this.basePath}/${symbol}`;
+ }
+
+ private getDataPath(symbol: string, interval: IntervalType) {
+ return `${this.getSymbolPath(symbol)}/${interval}.json`;
+ }
+
+ async saveMarketData(symbol: string, cacheEntry: CacheEntry): Promise {
+ await this.initialize();
+
+ // Ensure symbol directory exists
+ const symbolPath = this.getSymbolPath(symbol);
+ await this.ensureDirectory(symbolPath);
+
+ // Save data file
+ const dataPath = this.getDataPath(symbol, cacheEntry.interval);
+ await this.vault.adapter.write(
+ dataPath,
+ JSON.stringify(cacheEntry, null, 2)
+ );
+
+ // Update metadata
+ await this.updateMetadata(symbol, cacheEntry);
+ }
+
+ async getMarketData(symbol: string, interval: IntervalType): Promise {
+ const dataPath = this.getDataPath(symbol, interval);
+
+ if (await this.vault.adapter.exists(dataPath)) {
+ const content = await this.vault.adapter.read(dataPath);
+ const parsed = JSON.parse(content);
+ // Ensure we always return an array
+ return Array.isArray(parsed) ? parsed : [parsed];
+ }
+
+ return [];
+ }
+
+ private async updateMetadata(symbol: string, cacheEntry: CacheEntry) {
+ const metadataPath = `${this.basePath}/metadata.json`;
+ let metadata: CacheMetadata = {};
+ try{
+ if (await this.vault.adapter.exists(metadataPath)) {
+ const content = await this.vault.adapter.read(metadataPath);
+ metadata = JSON.parse(content);
+ }
+
+ // Update metadata for this symbol
+ metadata[symbol] = metadata[symbol] || {};
+ if (!metadata[symbol][cacheEntry.interval]) {
+ metadata[symbol][cacheEntry.interval] = [];
+ }
+
+ // Add new cache entry info
+ const cacheList = metadata[symbol][cacheEntry.interval];
+ if (cacheList) {
+ cacheList.push({
+ timestamp: cacheEntry.timestamp,
+ startTime: cacheEntry.startTime,
+ endTime: cacheEntry.endTime,
+ interval: cacheEntry.interval,
+ data: [], // Don't store actual data in metadata
+ timezone: cacheEntry.timezone
+ });
+
+ // Keep only last 5 entries
+ if (cacheList.length > 5) {
+ cacheList.shift();
+ }
+ }
+
+ await this.vault.adapter.write(
+ metadataPath,
+ JSON.stringify(metadata, null, 2)
+ );
+ }catch (error) {
+ console.error(`Failed to update metadata for ${symbol}:`, error);
+ throw new Error(`Failed to update metadata: ${error.message}`);
+ }
+ }
+
+ async getCacheStats(): Promise<{
+ totalSize: number;
+ symbolCount: number;
+ fileCount: number;
+ symbols: Record;
+ }> {
+ let totalSize = 0;
+ let fileCount = 0;
+ const symbols: Record = {};
+try{
+ if (await this.vault.adapter.exists(this.basePath)) {
+ const files = await this.vault.adapter.list(this.basePath);
+
+ for (const file of files.files) {
+ if (file.endsWith('.json')) {
+ const stat = await this.vault.adapter.stat(file);
+ if (!stat) continue; // Skip if stat is null
+ totalSize += stat.size;
+ fileCount++;
+
+ // Parse symbol and interval info
+ const pathParts = file.split('/');
+ if (pathParts.length >= 2) {
+ const symbol = pathParts[pathParts.length - 2];
+ const interval = pathParts[pathParts.length - 1].replace('.json', '') as IntervalType;
+
+ if (!symbols[symbol]) {
+ symbols[symbol] = {
+ intervals: [],
+ lastUpdated: stat.mtime
+ };
+ }
+ symbols[symbol].intervals.push(interval);
+ symbols[symbol].lastUpdated = Math.max(symbols[symbol].lastUpdated, stat.mtime);
+ }
+ }
+ }
+ }
+
+ return {
+ totalSize,
+ symbolCount: Object.keys(symbols).length,
+ fileCount,
+ symbols
+ };
+ } catch (error) {
+ console.error('Failed to get cache stats:', error);
+ return {
+ totalSize: 0,
+ symbolCount: 0,
+ fileCount: 0,
+ symbols: {}
+ };
+ }
+ }
+
+ async cleanup(maxAge: number = 7 * 24 * 60 * 60 * 1000) { // Default 7 days
+ const stats = await this.getCacheStats();
+ const now = Date.now();
+
+ for (const [symbol, info] of Object.entries(stats.symbols)) {
+ if (now - info.lastUpdated > maxAge) {
+ // Remove old symbol data
+ const symbolPath = this.getSymbolPath(symbol);
+ if (await this.vault.adapter.exists(symbolPath)) {
+ await this.vault.adapter.rmdir(symbolPath, true);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/types/babel-standalone.d.ts b/src/types/babel-standalone.d.ts
new file mode 100644
index 0000000..ac38a0a
--- /dev/null
+++ b/src/types/babel-standalone.d.ts
@@ -0,0 +1,31 @@
+// src/types/babel-standalone.d.ts
+declare module '@babel/standalone' {
+ export interface TransformOptions {
+ filename?: string;
+ presets?: (string | [string, object])[]; //Also allow tuple
+ plugins?: any[];
+ configFile?: boolean | string;
+ babelrc?: boolean;
+ sourceType?: 'script' | 'module' | 'unambiguous';
+ sourceMaps?: boolean;
+ sourceFileName?: string;
+ code?: boolean;
+ ast?: boolean;
+ minified?: boolean;
+ }
+
+ export interface TransformResult {
+ code: string;
+ map?: any;
+ ast?: any;
+ metadata?: any;
+ }
+
+ export function transform(
+ code: string,
+ options?: TransformOptions
+ ): TransformResult;
+
+ export const availablePresets: { [key: string]: any };
+ export const availablePlugins: { [key: string]: any };
+}
\ No newline at end of file
diff --git a/src/types/global.d.ts b/src/types/global.d.ts
new file mode 100644
index 0000000..1aa7d50
--- /dev/null
+++ b/src/types/global.d.ts
@@ -0,0 +1,7 @@
+declare global {
+ interface Window {
+ React: typeof import('react');
+ }
+}
+
+export {};
\ No newline at end of file
diff --git a/styles.css b/styles.css
new file mode 100644
index 0000000..8657e6a
--- /dev/null
+++ b/styles.css
@@ -0,0 +1,335 @@
+/* styles.css */
+
+/* Spacing utilities */
+.mt-1 { margin-top: 0.25rem; }
+.mt-2 { margin-top: 0.5rem; }
+.mt-4 { margin-top: 1rem; }
+.mb-2 { margin-bottom: 0.5rem; }
+.p-2 { padding: 0.5rem; }
+.p-4 { padding: 1rem; }
+
+/* Layout utilities */
+.flex { display: flex; }
+.grid { display: grid; }
+.grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.gap-2 { gap: 0.5rem; }
+.gap-4 { gap: 1rem; }
+
+.w-full { width: 100%; }
+.space-y-2 > * + * { margin-top: 0.5rem; }
+
+/* Colors - using Obsidian CSS variables */
+.text-green-500 { color: var(--color-green); }
+.text-red-500 { color: var(--color-red); }
+.text-blue-500 { color: var(--interactive-accent); }
+
+/* Font utilities */
+.font-medium { font-weight: 500; }
+.text-sm { font-size: 0.875rem; }
+.text-lg { font-size: 1.125rem; }
+
+
+/* Border utilities */
+.rounded { border-radius: 4px; }
+.border { border: 1px solid var(--background-modifier-border); }
+.border-slate-700 { border-color: var(--background-modifier-border-focus); }
+
+/* Component styles */
+.react-plugin-card {
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 4px;
+ background: var(--background-primary);
+ margin-bottom: 1rem; }
+
+.react-plugin-card-header {
+ padding: 1rem;
+ border-bottom: 1px solid var(--background-modifier-border); }
+
+.react-plugin-card-title {
+ margin: 0;
+ font-size: 1.1em;
+ font-weight: 600;
+ color: var(--text-normal); }
+
+.react-plugin-card-content { padding: 1rem; }
+
+.react-plugin-tabs {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem; }
+
+.react-plugin-tabs-list {
+ display: flex;
+ gap: 0.5rem;
+ border-bottom: 1px solid var(--background-modifier-border);
+ padding-bottom: 0.5rem; }
+
+.react-plugin-tab-trigger {
+ padding: 0.5rem 1rem;
+ border: none;
+ background: none;
+ cursor: pointer;
+ color: var(--text-muted);
+ border-radius: 4px; }
+
+.react-plugin-tab-trigger[data-state="active"] {
+ background: var(--background-modifier-hover);
+ color: var(--text-normal); }
+
+/* Chart container styles */
+.chart-container {
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 4px;
+ padding: 0;
+ margin: 0;
+ overflow: hidden; /* Add this to prevent any overflow */
+ min-height: 400px;
+ background: var(--background-secondary); }
+
+ .tv-lightweight-charts {
+ height: 500px !important; /* Force height if needed
+ overflow: visible; /* Show x-axis labels if they overflow */
+ }
+
+
+/* List styles */
+.list-content {
+ margin: 0;
+ padding-left: 1.5rem;
+ list-style-type: none; }
+
+.list-content li {
+ margin-bottom: 0.5rem;
+ color: var(--text-normal); }
+
+.heading {
+ margin: 0 0 0.5rem 0;
+ font-weight: 600; }
+
+/* Prevent conflicts with Obsidian's styles */
+.react-plugin-card button { box-shadow: none; }
+
+.react-plugin-card button:hover { box-shadow: none; }
+.react-component-error {
+ margin: 0.5rem 0;
+ font-size: 0.875rem;
+}
+
+.react-component-error pre {
+ white-space: pre-wrap;
+ word-break: break-word;
+}
+
+
+/* Dark mode adjustments are handled by Tailwind classes */
+/*
+
+This CSS file will be included with your plugin, and
+available in the app when your plugin is enabled.
+
+If your plugin does not need CSS, delete this file.
+
+*/
+
+/* Chart container styles */
+.recharts-wrapper {
+ min-height: 400px !important;
+ min-width: 300px !important;
+}
+
+/* Ensure proper sizing for ResponsiveContainer */
+.recharts-responsive-container {
+ min-height: 400px !important;
+ width: 100% !important;
+}
+
+/* Dark mode adjustments for charts */
+.theme-dark .recharts-cartesian-grid line {
+ stroke: rgba(255, 255, 255, 0.1);
+}
+
+.theme-dark .recharts-text {
+ fill: rgba(255, 255, 255, 0.8);
+}
+
+.theme-dark .recharts-tooltip-wrapper {
+ background-color: #1a1b1e;
+ border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+
+/*Tail Wind stuff */
+/* styles.css */
+
+/* Layout */
+.w-full { width: 100%; }
+.w-3\/4 { width: 75%; }
+.w-1\/2 { width: 50%; }
+.h-64 { height: 16rem; }
+.h-32 { height: 8rem; }
+.h-16 { height: 4rem; }
+.relative { position: relative; }
+.absolute { position: absolute; }
+
+/* Spacing */
+.p-4 { padding: 1rem; }
+.mt-16 { margin-top: 4rem; }
+.mt-8 { margin-top: 2rem; }
+.mt-4 { margin-top: 1rem; }
+.mb-4 { margin-bottom: 1rem; }
+.ml-8 { margin-left: 2rem; }
+.top-2 { top: 0.5rem; }
+.left-2 { left: 0.5rem; }
+
+/* Block colors - with dark mode support */
+.bg-red-200 {
+ background-color: rgba(254, 202, 202, 0.8);
+}
+.bg-orange-200 {
+ background-color: rgba(254, 215, 170, 0.8);
+}
+.bg-yellow-200 {
+ background-color: rgba(254, 240, 138, 0.8);
+}
+.bg-slate-100 {
+ background-color: rgba(241, 245, 249, 0.8);
+}
+
+.theme-dark .bg-red-200 {
+ background-color: rgba(254, 202, 202, 0.2);
+}
+.theme-dark .bg-orange-200 {
+ background-color: rgba(254, 215, 170, 0.2);
+}
+.theme-dark .bg-yellow-200 {
+ background-color: rgba(254, 240, 138, 0.2);
+}
+.theme-dark .bg-slate-100 {
+ background-color: rgba(241, 245, 249, 0.1);
+}
+
+/* Border colors */
+.border-red-500 { border-color: rgb(239, 68, 68); }
+.border-orange-500 { border-color: rgb(249, 115, 22); }
+.border-yellow-500 { border-color: rgb(234, 179, 8); }
+
+/* Border styles */
+.border-2 { border-width: 2px; }
+.rounded-lg { border-radius: 0.5rem; }
+
+/* Grid */
+.grid { display: grid; }
+.grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.gap-4 { gap: 1rem; }
+
+/* Typography */
+.text-sm { font-size: 0.875rem; }
+.font-medium { font-weight: 500; }
+
+/* Flex */
+.flex { display: flex; }
+.items-center { align-items: center; }
+
+/* Spacing utilities */
+.space-y-4 > * + * { margin-top: 1rem; }
+.space-y-2 > * + * { margin-top: 0.5rem; }
+
+/* Container styles - ensures proper rendering in Obsidian */
+.react-component-container {
+ width: 100%;
+ margin: 1rem 0;
+ font-family: var(--font-interface);
+ color: var(--text-normal);
+}
+
+.theme-dark .react-component-container {
+ color-scheme: dark;
+}
+
+/* Card styles */
+.card {
+ background-color: var(--background-primary);
+ border: 1px solid var(--background-modifier-border);
+ border-radius: 0.5rem;
+ width: 100%;
+}
+
+.card-header {
+ padding: 1.5rem;
+}
+
+.card-title {
+ font-size: 1.5rem;
+ font-weight: 600;
+ margin: 0;
+}
+
+.card-content {
+ padding: 1.5rem;
+}
+
+
+
+
+
+/* Base text positioning */
+.nested-block-label {
+ position: absolute;
+ top: 8px;
+ left: 8px;
+ font-size: 0.875rem;
+ font-weight: 500;
+ z-index: 10; /* Ensure text stays above blocks */
+ background-color: inherit; /* Match parent block background */
+ padding: 2px 6px;
+ border-radius: 4px;
+}
+
+/* Ensure blocks stack properly */
+.nested-block {
+ position: relative;
+ border: 2px solid;
+ border-radius: 8px;
+ margin-bottom: 1rem;
+ z-index: 1; /* Base z-index */
+}
+
+/* Specific z-indices for each block type */
+.nested-block.primary {
+ z-index: 1;
+}
+
+.nested-block.secondary {
+ z-index: 2;
+}
+
+.nested-block.tertiary {
+ z-index: 3;
+}
+
+/* Adjust backgrounds to be slightly transparent */
+.bg-red-200 {
+ background-color: rgba(254, 202, 202, 0.95);
+}
+.bg-orange-200 {
+ background-color: rgba(254, 215, 170, 0.95);
+}
+.bg-yellow-200 {
+ background-color: rgba(254, 240, 138, 0.95);
+}
+
+/* Dark mode adjustments */
+.theme-dark .bg-red-200 {
+ background-color: rgba(254, 202, 202, 0.15);
+}
+.theme-dark .bg-orange-200 {
+ background-color: rgba(254, 215, 170, 0.15);
+}
+.theme-dark .bg-yellow-200 {
+ background-color: rgba(254, 240, 138, 0.15);
+}
+
+/* Ensure proper spacing */
+.nested-block + .nested-block {
+ margin-top: 2rem;
+}
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..5a6775c
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,37 @@
+{
+ "compilerOptions": {
+ "baseUrl": ".",
+ "inlineSourceMap": true,
+ "inlineSources": true,
+ "module": "ESNext",
+ "target": "ES2020",
+ "allowJs": true,
+ "noImplicitAny": true,
+ "moduleResolution": "node",
+ "importHelpers": true,
+ "isolatedModules": true,
+ "strictNullChecks": true,
+ "allowSyntheticDefaultImports": true,
+ "jsx": "react",
+ "jsxFactory": "React.createElement", // Add this
+ "jsxFragmentFactory": "React.Fragment", // Add this
+ "lib": [
+ "DOM",
+ "ES5",
+ "ES6",
+ "ES7",
+ "ES2020"
+ ],
+ "typeRoots": [
+ "./node_modules/@types",
+ "./src/types"
+ ]
+ },
+ "include": [
+ "**/*.ts",
+ "**/*.tsx",
+ "src/**/*.ts",
+ "src/**/*.tsx",
+ "src/types/**/*.d.ts"
+ ]
+}
diff --git a/version-bump.mjs b/version-bump.mjs
new file mode 100644
index 0000000..d409fa0
--- /dev/null
+++ b/version-bump.mjs
@@ -0,0 +1,14 @@
+import { readFileSync, writeFileSync } from "fs";
+
+const targetVersion = process.env.npm_package_version;
+
+// read minAppVersion from manifest.json and bump version to target version
+let manifest = JSON.parse(readFileSync("manifest.json", "utf8"));
+const { minAppVersion } = manifest;
+manifest.version = targetVersion;
+writeFileSync("manifest.json", JSON.stringify(manifest, null, "\t"));
+
+// update versions.json with target version and minAppVersion from manifest.json
+let versions = JSON.parse(readFileSync("versions.json", "utf8"));
+versions[targetVersion] = minAppVersion;
+writeFileSync("versions.json", JSON.stringify(versions, null, "\t"));
diff --git a/versions.json b/versions.json
new file mode 100644
index 0000000..26382a1
--- /dev/null
+++ b/versions.json
@@ -0,0 +1,3 @@
+{
+ "1.0.0": "0.15.0"
+}