raain-ui 2.3.5 → 2.3.7

package/CHANGELOG.md

@@ -0,0 +1,55 @@
+# Changelog
+
+All notable changes to the raain-ui project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.3.x] - Current
+
+### Added
+- Cartesian earth optimization for improved performance
+
+## [2.2.x]
+
+### Enhanced
+- Model polar visualization improvements
+
+## [2.1.x]
+
+### Added
+- Support for icons in composite layers
+
+## [2.0.x]
+
+### Changed
+- Updated raain-model integration
+
+## [1.11.x]
+
+### Changed
+- Refactored Factory components
+
+### Added
+- Performance monitoring capabilities
+
+## [1.10.x]
+
+### Fixed
+- Cartesian visualization issues
+
+### Added
+- Show/hide capability for UI elements
+
+## [1.0.x - 1.9.x]
+
+### Added
+- Various factories for UI components:
+  - Map integration
+  - Compare functionality
+  - Configuration options
+
+## [0.x.x]
+
+### Added
+- Initial release with core components extracted from RAAIN project

package/GUIDELINES.md

@@ -0,0 +1,168 @@
+# raain-ui Development Guidelines
+
+This document provides essential information for developers working on the raain-ui project.
+
+## Build and Configuration Instructions
+
+### Prerequisites
+- Node.js and npm
+
+### Setup
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+### Build Commands
+- **Build the project**:
+  ```bash
+  npm run build
+  ```
+  This command:
+  - Removes the existing `dist` directory
+  - Compiles TypeScript files according to `tsconfig.json`
+  - Copies markdown files and package.json to the dist directory
+
+- **Clean and reinstall**:
+  ```bash
+  npm run _clean
+  ```
+  This removes generated directories, logs, and node_modules, then reinstalls dependencies.
+
+- **Build with version increment**:
+  ```bash
+  npm run build-version
+  ```
+  This increments the patch version in package.json before building.
+
+### TypeScript Configuration
+The project uses TypeScript with the following key configurations:
+- Target: ES2017
+- Module: CommonJS
+- Declaration files are generated
+- Entry point: `./src/index.ts`
+- Output directory: `./dist/`
+
+## Testing Information
+
+### Test Configuration
+The project uses:
+- **Mocha**: Test runner
+- **Chai**: Assertion library
+- **NYC (Istanbul)**: Code coverage tool
+- **Mock-Browser**: For mocking browser environment in tests
+
+### Running Tests
+- **Run all tests**:
+  ```bash
+  npm test
+  ```
+
+- **Run specific tests** (using grep pattern):
+  ```bash
+  npm test -- -g "pattern"
+  ```
+  Example:
+  ```bash
+  npm test -- -g "should convert RGB string to hex"
+  ```
+
+### Test Environment
+Tests run in a Node.js environment with:
+- A mocked browser environment for Leaflet and Pixi.js components
+- TypeScript support via ts-node
+
+### Adding New Tests
+1. Create test files in the `specs` directory, mirroring the structure of the `src` directory
+2. Name test files with `.spec.ts` extension
+3. Use Mocha's `describe` and `it` functions for test organization
+4. Use Chai's `expect` for assertions
+
+### Example Test
+Here's a simple test for the `rgbStringToHex` method in the `Tools` class:
+
+```typescript
+import {expect} from 'chai';
+import {Tools} from '../../src';
+
+describe('Factories.Tools', () => {
+    it('should convert RGB string to hex', async () => {
+        // Test basic RGB to hex conversion
+        expect(Tools.rgbStringToHex('rgb(255, 0, 0)')).eq('#ff0000');
+        expect(Tools.rgbStringToHex('rgb(0, 255, 0)')).eq('#00ff00');
+
+        // Test error cases
+        try {
+            Tools.rgbStringToHex('invalid');
+            expect.fail('Should have thrown an error for invalid RGB string');
+        } catch (error) {
+            expect(error.message).eq('Invalid RGB string format');
+        }
+    });
+});
+```
+
+## Code Style and Development Guidelines
+
+### Code Style
+The project uses TSLint with the following key rules:
+- Single quotes for strings
+- Maximum line length of 140 characters
+- Member ordering: static fields, instance fields, static methods, instance methods
+- No requirement for interface names to start with "I"
+- No requirement for explicit member access modifiers
+
+### Documentation
+- Use JSDoc comments for classes, methods, and properties
+- Include parameter descriptions and return types
+- Document thrown exceptions
+
+### Project Structure
+- `src/`: Source code
+  - `drawers/`: Drawing components
+  - `factories/`: Factory classes
+  - `layers/`: Layer components
+  - `timeframes/`: Time-related components
+  - `tools/`: Utility tools
+- `specs/`: Test files (mirrors src structure)
+- `example/`: Example usage
+- `tools/`: Build and test utilities
+- `dist/`: Compiled output (generated)
+
+### Dependencies
+The project uses:
+- Chart.js for charting
+- Leaflet for maps
+- Pixi.js for rendering
+- raain-model for data models
+
+### Example Usage
+The project includes an example application in the `example` directory that demonstrates how to use the library:
+
+1. **Build the library first**:
+   ```bash
+   npm run build
+   ```
+
+2. **Run the example**:
+   ```bash
+   cd example
+   npm start
+   ```
+   This will:
+   - Clean the example directory
+   - Install dependencies
+   - Start a Parcel development server
+   - Open the example in your browser
+
+3. **Build the example for production**:
+   ```bash
+   cd example
+   npm run build
+   ```
+   This creates a production build in the `example/dist` directory.
+
+### Common Issues and Solutions
+- When testing components that use browser APIs, ensure the mock browser environment is properly set up
+- Some tests may fail due to timezone differences; use timezone-independent assertions when testing date formatting

package/README.md

@@ -1,19 +1,73 @@
 # raain-ui
 
-Please read the [specifications](./specs).
+UI components and visualization layers for raain.io applications.
+
+## Description
+
+raain-ui is a library that provides UI components and visualization layers for displaying and interacting with rainfall data. It uses Leaflet for maps, Pixi.js for rendering, and Chart.js for charting.
+
+## Installation
 
-or try the [example](./example) :
 ```bash
-npm i
+npm install raain-ui
+```
+
+## Usage
+
+### Basic Setup
+
+```javascript
+import { MapElement } from 'raain-ui';
+
+// Create a map element
+const mapElement = new MapElement({
+  container: 'map-container',
+  center: [51.505, -0.09],
+  zoom: 13
+});
+```
+
+### Example Application
+
+The project includes an example application that demonstrates how to use the library:
+
+```bash
+# Clone the repository
+git clone https://github.com/raainio/raain-ui.git
+cd raain-ui
+
+# Install dependencies and build the library
+npm install
 npm run build
+
+# Run the example
 cd example/
-npm start 
+npm start
 ```
-=> http://localhost:1234
 
-## History
+This will open the example application at http://localhost:1234
+
+## Development
+
+Please read the [Development Guidelines](./GUIDELINES.md) for detailed information about:
+- Build and configuration instructions
+- Testing information
+- Code style and development guidelines
+- Project structure
+- Dependencies
+
+## Documentation
 
-See [Release notes](./RELEASE.md).
+API documentation is available in the [specifications](./specs) directory.
+
+## Changelog
+
+See the [Changelog](./CHANGELOG.md) for a list of changes in each version.
+
+## Release Process
+
+See the [Release Process](./RELEASE_PROCESS.md) for information about how releases are managed.
 
 ## License
+
 MIT

package/RELEASE_PROCESS.md

@@ -0,0 +1,92 @@
+# Release Process
+
+This document outlines the process for creating and publishing new releases of the raain-ui library.
+
+## Version Numbering
+
+raain-ui follows [Semantic Versioning](https://semver.org/) (SemVer):
+
+- **MAJOR** version for incompatible API changes (X.y.z)
+- **MINOR** version for backwards-compatible functionality additions (x.Y.z)
+- **PATCH** version for backwards-compatible bug fixes (x.y.Z)
+
+## Release Steps
+
+### 1. Preparation
+
+1. Ensure all tests pass:
+   ```bash
+   npm test
+   ```
+
+2. Update documentation if necessary:
+    - README.md
+    - API documentation
+    - Example code
+
+3. Update the CHANGELOG.md file:
+    - Add a new section for the release version
+    - Document all notable changes since the last release
+    - Categorize changes as Added, Changed, Fixed, etc.
+
+### 2. Version Bump
+
+1. Use the built-in version increment script for patch releases:
+   ```bash
+   npm run build-version
+   ```
+
+   Or manually update the version in package.json for minor or major releases.
+
+### 3. Build and Test the Release
+
+1. Clean the project and reinstall dependencies:
+   ```bash
+   npm run _clean
+   ```
+
+2. Build the project:
+   ```bash
+   npm run build
+   ```
+
+3. Run tests again to ensure everything works with the built version:
+   ```bash
+   npm test
+   ```
+
+### 4. Publish to npm
+
+Do not it manually, it's done by GitHub CI by pushing in the master branch.
+
+### 5. Create a Git Tag and Release
+
+1. Create a git tag for the release:
+   ```bash
+   git tag -a v<version> -m "Release v<version>"
+   ```
+
+2. Push the tag to the repository:
+   ```bash
+   git push origin v<version>
+   ```
+
+3. Create a release on GitHub:
+    - Go to the repository's Releases page
+    - Create a new release using the tag
+    - Copy the relevant section from CHANGELOG.md as the release description
+
+## Hotfix Process
+
+For critical bug fixes that need to be released outside the normal release cycle:
+
+1. Create a hotfix branch from the latest release tag
+2. Fix the issue and commit the changes
+3. Follow the normal release process, but increment only the patch version
+4. After publishing, merge the hotfix back into the main development branch
+
+## Post-Release
+
+1. Update the example application to use the new version if necessary
+2. Notify users of the new release through appropriate channels
+3. Monitor for any issues reported by users

package/drawers/CartesianDrawer.d.ts

@@ -22,6 +22,7 @@ export declare class CartesianDrawer implements IDrawer {
     getOptimization(): CartesianDrawerOptimization;
     updateValues(geoValues: CartesianMapValue[], version: string): void;
     hasChanged(center: MapLatLng, centerPoint: Point): boolean;
+    getExecOfWindowPoints(values: CartesianMapValue[], fnToApplyToAllPoint: (c: CartesianMapValue[]) => any): any;
     getExecOfVisiblePoints(values: CartesianMapValue[], fnToApplyToAllPoint: (c: CartesianMapValue[]) => any): any;
     renderCartesianMapValues(center: MapLatLng, centerPoint: Point, drawShape: (gridValue: GridValue) => boolean): number;
     protected createGridValue(mapValue: CartesianMapValue, points: {

package/drawers/CartesianDrawer.js

@@ -42,6 +42,10 @@ class CartesianDrawer {
         }
         return this.distanceRatio !== this.getDistanceRatio(center);
     }
+    getExecOfWindowPoints(values, fnToApplyToAllPoint) {
+        const filteredValues = values.filter(this.cartesianMap2Display);
+        return fnToApplyToAllPoint(filteredValues);
+    }
     getExecOfVisiblePoints(values, fnToApplyToAllPoint) {
         const optimization = this.getOptimization();
         const filteredValues = optimization.filteringValues(this.cartesianMapZoom(), values, this.cartesianMap2Display);
@@ -74,4 +78,4 @@ class CartesianDrawer {
     }
 }
 exports.CartesianDrawer = CartesianDrawer;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FydGVzaWFuRHJhd2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RyYXdlcnMvQ2FydGVzaWFuRHJhd2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUE4QjtBQUU5QixvQ0FBZ0U7QUFDaEUsNkRBQXdEO0FBQ3hELCtFQUEwRTtBQUkxRSxNQUFhLGVBQWU7SUFTeEIsWUFBb0IsbUJBQThFLEVBQzlFLG9CQUE4RCxFQUM5RCxnQkFBOEIsRUFDOUIsSUFBWTtRQUhaLHdCQUFtQixHQUFuQixtQkFBbUIsQ0FBMkQ7UUFDOUUseUJBQW9CLEdBQXBCLG9CQUFvQixDQUEwQztRQUM5RCxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWM7UUFDOUIsU0FBSSxHQUFKLElBQUksQ0FBUTtRQUM1QixJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQztRQUNwQixJQUFJLENBQUMsYUFBYSxHQUFHLENBQUMsQ0FBQztRQUN2QixJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksZUFBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUNuQyxJQUFJLENBQUMsYUFBYSxHQUFHLHlEQUEyQixDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ2hFLENBQUM7SUFFTSxVQUFVO1FBQ2IsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3hCLENBQUM7SUFFTSxnQkFBZ0IsQ0FBQyxLQUFhLEVBQ2IsS0FBYSxFQUNiLGFBQTRDO1FBQ2hFLElBQUksQ0FBQyxhQUFhLEdBQUcsYUFBYSxDQUFDO0lBQ3ZDLENBQUM7SUFFTSxlQUFlO1FBQ2xCLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7WUFDbEQsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3JFLENBQUMsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxhQUFhLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQzdCLE9BQU8sYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzVCLENBQUM7UUFFRCwyRkFBMkY7UUFDM0YsT0FBTyx5REFBMkIsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyRCxDQUFDO0lBRU0sWUFBWSxDQUFDLFNBQThCLEVBQUUsT0FBZTtRQUMvRCxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUMzQixDQUFDO0lBRU0sVUFBVSxDQUFDLE1BQWlCLEVBQUUsV0FBa0I7UUFDbkQsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7WUFDeEMsT0FBTyxJQUFJLENBQUM7UUFDaEIsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLGFBQWEsS0FBSyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVNLHFCQUFxQixDQUFDLE1BQTJCLEVBQUUsbUJBQW9EO1FBQzFHLE1BQU0sY0FBYyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLG9CQUFvQixDQUFDLENBQUM7UUFDaEUsT0FBTyxtQkFBbUIsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRU0sc0JBQXNCLENBQUMsTUFBMkIsRUFBRSxtQkFBb0Q7UUFFM0csTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQzVDLE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBQ2hILE9BQU8sbUJBQW1CLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDL0MsQ0FBQztJQUVNLHdCQUF3QixDQUFDLE1BQWlCLEVBQUUsV0FBa0IsRUFDckMsU0FBNEM7UUFFeEUsSUFBSSxJQUFJLEdBQUcsQ0FBQyxDQUFDO1FBQ2IsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDbkQsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQzVDLE1BQU0sY0FBYyxHQUFHLFlBQVksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUV4SCxLQUFLLE1BQU0sUUFBUSxJQUFJLGNBQWMsRUFBRSxDQUFDO1lBQ3BDLElBQUksSUFBSSxHQUFHLFlBQVksQ0FBQyxTQUFTLEVBQUUsQ0FBQztnQkFDaEMsT0FBTyxDQUFDLElBQUksQ0FBQywrQkFBK0IsRUFBRSxZQUFZLENBQUMsU0FBUyxDQUFDLENBQUM7Z0JBQ3RFLE1BQU07WUFDVixDQUFDO1lBQ0QsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBRWxELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxXQUFXLENBQUMsQ0FBQztZQUV0RSxJQUFJLFNBQVMsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO2dCQUN2QixJQUFJLEVBQUUsQ0FBQztZQUNYLENBQUM7UUFFTCxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUVTLGVBQWUsQ0FBQyxRQUEyQixFQUFFLE1BQWdDLEVBQUUsV0FBa0I7UUFDdkcsT0FBTyx1Q0FBa0IsQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUMsQ0FBQztJQUNoSCxDQUFDO0lBRU8sZ0JBQWdCLENBQUMsV0FBc0I7UUFDM0MsT0FBTyxnQkFBUSxDQUFDLHlCQUF5QixDQUNyQyxXQUFXLEVBQ1gsSUFBSSxDQUFDLFNBQVMsRUFDZCxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQztJQUNsQyxDQUFDO0NBRUo7QUF0R0QsMENBc0dDIn0=

package/drawers/IDrawer.d.ts

@@ -1,3 +1,4 @@
 export interface IDrawer {
+    getExecOfWindowPoints(values: any, fnToApplyToAllPoint: (c: any) => any): any;
     getExecOfVisiblePoints(values: any, fnToApplyToAllPoint: (c: any) => any): any;
 }

package/drawers/PolarDrawer.d.ts

@@ -20,6 +20,7 @@ export declare class PolarDrawer implements IDrawer {
     getOptimization(): PolarDrawerOptimization;
     updateValues(geoValues: PolarMapValue[], version: string): void;
     hasChanged(center: MapLatLng, centerPoint: Point): boolean;
+    getExecOfWindowPoints(values: PolarMapValue[], fnToApplyToAllPoint: (c: PolarMapValue[]) => any): any;
     getExecOfVisiblePoints(values: PolarMapValue[], fnToApplyToAllPoint: (v: PolarMapValue[]) => any): any;
     renderPolarMapValues(center: MapLatLng, centerPoint: Point, drawPolarSharp: (polar1: PolarGridValue, polar2?: PolarGridValue) => boolean): number;
     _getNextOffset(index: any, edgeCount: any): number;

package/drawers/PolarDrawer.js

@@ -46,6 +46,10 @@ class PolarDrawer {
         }
         return this.possibleDrawing !== this.getPossibleDrawing();
     }
+    getExecOfWindowPoints(values, fnToApplyToAllPoint) {
+        const filteredValues = values.filter(this.polarMap2Display);
+        return fnToApplyToAllPoint(filteredValues);
+    }
     getExecOfVisiblePoints(values, fnToApplyToAllPoint) {
         const optimization = this.getOptimization();
         const filteredValues = optimization.filteringValues(this.polarMapZoom(), values, this.polarMap2Display);
@@ -183,4 +187,4 @@ class PolarDrawer {
     }
 }
 exports.PolarDrawer = PolarDrawer;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PolarDrawer.js","sourceRoot":"","sources":["../../src/drawers/PolarDrawer.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PolarDrawer.js","sourceRoot":"","sources":["../../src/drawers/PolarDrawer.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raain-ui",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "author": "contact@raain.io",
   "homepage": "https://github.com/raainio/raain-ui",
   "description": "raain.io ui layers",

package/RELEASE.md

@@ -1,10 +0,0 @@
-# Release notes
-
-- 0.x.x : first extracts from RAAIN
-- 1.(-)9.x : factories uses in UI (map, compare, config)
-- 1.10.x : UI feedbacks (fix cartesians, add show/hide capability)
-- 1.11.x : Factory refactored, perf monitoring added
-- 2.0.x : change raain-model
-- 2.1.x : composite layer could include icons
-- 2.2.x : model polar enhancement
-- 2.3.x : cartesian earth optimization