# Base Path Module Resolver Example

This example demonstrates the use of the `BasePathModuleResolver` for simplifying Rhai script module imports.

## Overview

The `BasePathModuleResolver` provides a more predictable and consistent approach to module resolution by:

1. Using a single base path for resolving all module imports
2. Eliminating the complexity of resolving imports relative to the importing file
3. Requiring all import paths to be specified relative to the base path

## Directory Structure

The example follows a hierarchical directory structure:

```
base_path_imports/
├── components/
│   ├── calendar/
│   │   └── controller/
│   │       └── mock/
│   │           └── calendar_model.rhai
│   ├── common/
│   │   └── utils/
│   │       ├── date_utils.rhai
│   │       └── string_utils.rhai
│   └── website/
│       └── controller/
│           └── mock/
│               └── website_model.rhai
├── main.rhai
└── src/
    └── main.rs
```

## Key Components

### 1. BasePathModuleResolver

Located in `rhai_factory/src/relative_resolver.rs`, this resolver simplifies module imports by:

- Taking a base path during initialization
- Resolving all module imports relative to this base path
- Providing clear logging of the resolution process

### 2. Utility Modules

Common utility functions are organized in the `components/common/utils/` directory:

- `string_utils.rhai`: Basic string manipulation functions
- `date_utils.rhai`: Date formatting and validation functions

### 3. Component-Specific Modules

Component-specific functionality is organized in dedicated directories:

- `components/calendar/controller/mock/calendar_model.rhai`: Calendar event creation and validation
- `components/website/controller/mock/website_model.rhai`: Website page creation and validation

### 4. Main Script

The `main.rhai` script demonstrates importing and using modules from different components.

## Running the Example

To run the example:

```bash
cd rhai_factory/examples/base_path_imports
cargo run
```

## Key Benefits

1. **Simplified Imports**: All imports are relative to a single base path
2. **Predictable Resolution**: No need to calculate relative paths between files
3. **Cleaner Code**: No need for complex "../../../" style paths
4. **Better Organization**: Encourages a modular, component-based structure
5. **Improved Debugging**: Clear logging of the module resolution process

## Implementation Details

The example demonstrates:

1. Setting up the `BasePathModuleResolver` with a base path
2. Importing modules using paths relative to the base path
3. Using utility functions from common modules
4. Creating component-specific functionality that leverages common utilities