grenton-ts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rpaczkow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# grenton-ts
+
+TypeScript API library for [Grenton](https://grenton.com) smart home hardware modules. Provides type-safe wrappers around the low-level Grenton hardware interfaces, making it easier to interact with Grenton devices in TypeScript projects.
+
+## Overview
+
+Grenton devices expose a raw Lua-based API. This library wraps those raw interfaces with typed TypeScript classes, giving you:
+
+- **Typed properties** with getters/setters
+- **Typed events** with callback registration
+- **Typed methods** for executing device commands
+- **Remote variants** for cross-gate (CLU-to-CLU) communication
+
+
+
+Each hardware module directory contains firmware-versioned subdirectories (e.g. `fv03_02`) so multiple firmware versions of the same module can coexist.
+
+## Architecture
+
+Every module follows the same three-layer pattern:
+
+### 1. Raw Interface (`*Raw`)
+
+A `declare class` mirroring the low-level hardware API:
+
+```typescript
+declare class RollerShutterRaw {
+    add_event(event: EventType, callback: () => void): void;
+    get(property: PropertyType): any;
+    set(property: PropertyType, value: any): void;
+    execute(method: MethodType, ...args: any[]): any;
+}
+```
+
+### 2. Wrapper Class
+
+A high-level class that takes the raw interface in its constructor and exposes typed methods, properties, and event registration:
+
+```typescript
+import { RollerShutter, RollerShutterRaw } from './roller-shutter-din-3/fv03_02/roller-shutter';
+
+const shutter = new RollerShutter(rawRollerShutter);
+
+// Events
+shutter.addOnPositionChange(() => {
+    console.log('Position:', shutter.position);
+});
+
+// Methods
+shutter.moveUp(5000);     // move up for 5 seconds
+shutter.setPosition(50);  // set to 50% open
+
+// Properties
+logInfo(shutter.state);    // StateType enum value
+logInfo(shutter.position); // number (0–100)
+shutter.maxTime = 30000;       // read/write property
+```
+
+### 3. Remote Variant (`*Remote`)
+
+For controlling devices on a different CLU via `RemoteGate`. Uses `rawExecutionBuilderFactory` to build command strings sent over the gate. Remote events are not supported.
+
+```typescript
+import { RollerShutterRemote } from './roller-shutter-din-3/fv03_02/roller-shutter';
+import { RemoteGate } from './core/remote-gate';
+
+const gate = new RemoteGate(rawRemoteGate);
+const shutter = new RollerShutterRemote('ROLLER_SHUTTER_1', gate);
+
+shutter.moveUp(5000);
+shutter.setPosition(75);
+```
+
+
+## Build
+
+```bash
+npm run build   # compile TypeScript → dist/
+npm run watch   # watch mode
+```
+
+Requires Node.js with TypeScript 5.x (`devDependency`). Compiled output goes to `dist/`.
+
+## License
+
+MIT

package/dist/analog-din/fv02_01/analog-in.ts

@@ -0,0 +1,271 @@
+import { rawExecutionBuilderFactory } from "../../core/execution-builder"
+import { RemoteGate } from "../../core/remote-gate"
+
+enum EventType {
+	OnValueChange = 0,
+	OnValueLower = 1,
+	OnValueRise = 2,
+	OnOutOfRange = 3,
+	OnSwitchOn = 4,
+	OnSwitchOff = 5,
+	OnInRange = 6
+}
+
+enum PropertyType {
+	Value = 0,
+	ValuesPercent = 1,
+	Scale = 2,
+	Sensivity = 3,
+	RawValue = 4,
+	MinValue = 5,	
+	MaxValue = 6
+}
+
+enum MethodType {}
+
+declare class AnalogInRaw {
+    add_event(event: EventType, callback: () => void): void
+    set(property: PropertyType, value: any): void
+    get(property: PropertyType): any
+    execute(method: MethodType, ...args: any[]): void
+}
+
+interface IAnalogIn {
+    addOnValueChange: (callback: () => void) => void
+    addOnValueLower: (callback: () => void) => void
+    addOnValueRise: (callback: () => void) => void
+    addOnOutOfRange: (callback: () => void) => void
+    addOnSwitchOn: (callback: () => void) => void
+    addOnSwitchOff: (callback: () => void) => void
+    addOnInRange: (callback: () => void) => void
+    readonly rawValue: number
+    readonly value: number
+    readonly valuePercent: number
+    scale: number
+    sensivity: number
+    minValue: number
+    maxValue: number
+}
+
+class AnalogIn implements IAnalogIn{
+    private onValueChangeCallbacks: Array<() => void> = [];
+    private onValueLowerCallbacks: Array<() => void> = [];
+    private onValueRiseCallbacks: Array<() => void> = [];
+    private onOutOfRangeCallbacks: Array<() => void> = [];
+    private onSwitchOnCallbacks: Array<() => void> = [];
+    private onSwitchOffCallbacks: Array<() => void> = [];
+    private onInRangeCallbacks: Array<() => void> = [];
+
+    constructor(private ain: AnalogInRaw) {
+        this.ain.add_event(EventType.OnValueChange, () => {
+            this.onValueChangeCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnValueLower, () => {
+            this.onValueLowerCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnValueRise, () => {
+            this.onValueRiseCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnOutOfRange, () => {
+            this.onOutOfRangeCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnSwitchOn, () => {
+            this.onSwitchOnCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnSwitchOff, () => {
+            this.onSwitchOffCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.ain.add_event(EventType.OnInRange, () => {
+            this.onInRangeCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+    }
+
+    addOnValueChange(callback: () => void): void {
+        this.onValueChangeCallbacks.push(callback);
+    }
+    addOnValueLower(callback: () => void): void {
+        this.onValueLowerCallbacks.push(callback);
+    }
+    addOnValueRise(callback: () => void): void {
+        this.onValueRiseCallbacks.push(callback);
+    }
+    addOnOutOfRange(callback: () => void): void {
+        this.onOutOfRangeCallbacks.push(callback);
+    }
+    addOnSwitchOn(callback: () => void): void {
+        this.onSwitchOnCallbacks.push(callback);
+    }
+    addOnSwitchOff(callback: () => void): void {
+        this.onSwitchOffCallbacks.push(callback);
+    }
+    addOnInRange(callback: () => void): void {
+        this.onInRangeCallbacks.push(callback);
+    }
+    get rawValue(): number{
+        return this.ain.get(PropertyType.RawValue)
+    }
+    get value(): number{
+        return this.ain.get(PropertyType.Value)
+    }
+    get valuePercent(): number{
+        return this.ain.get(PropertyType.ValuesPercent)
+    }
+    get scale(): number{
+        return this.ain.get(PropertyType.Scale)
+    }
+    set scale(value: number){
+        this.ain.set(PropertyType.Scale, value)
+    }
+    get sensivity(): number{
+        return this.ain.get(PropertyType.Sensivity)
+    }
+    set sensivity(value: number){
+        this.ain.set(PropertyType.Sensivity, value)
+    }
+    get minValue(): number{
+        return this.ain.get(PropertyType.MinValue)
+    }
+    set minValue(value: number){
+        this.ain.set(PropertyType.MinValue, value)
+    }
+    get maxValue(): number{
+        return this.ain.get(PropertyType.MaxValue)
+    }
+    set maxValue(value: number){
+        this.ain.set(PropertyType.MaxValue, value)
+    }
+}
+
+class AnalogInRemote implements IAnalogIn {
+    constructor(private objectName: string, private gate: RemoteGate){
+
+    }
+
+    addOnValueChange(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnValueLower(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnValueRise(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnOutOfRange(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnSwitchOn(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnSwitchOff(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    addOnInRange(_callback: () => void): void {
+        // Remote events are not supported
+    }
+
+    get rawValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.RawValue)
+            .build();
+
+        return this.gate.runScript(cmd!);
+    }
+
+    get value(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Value)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    get valuePercent(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.ValuesPercent)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    get scale(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Scale)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set scale(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Scale)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get sensivity(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Sensivity)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set sensivity(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Sensivity)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get minValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.MinValue)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set minValue(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MinValue)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+    get maxValue(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.MaxValue)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+    set maxValue(value: number) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.MaxValue)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+}
+
+export { AnalogIn, AnalogInRaw, AnalogInRemote} 

package/dist/clu/calendar/v1/calendar.ts

@@ -0,0 +1,308 @@
+// Created from: packages/grenton-api/interfaces/object_calendar_v1.xml, object name="Calendar" version="1"
+
+import { rawExecutionBuilderFactory } from "../../../core/execution-builder"
+import { RemoteGate } from "../../../core/remote-gate"
+
+enum EventType {
+    OnCalendar = 0,
+    OnStart = 1,
+    OnStop = 2,
+    OnCancel = 3
+}
+
+enum PropertyType {
+    Rule = 0,
+    SinceLastRun = 1,
+    ToNextRun = 2,
+    State = 3
+}
+
+enum MethodType {
+    Start = 0,
+    Stop = 1,
+    CancelNext = 3
+}
+
+enum StateType {
+    Off = 0,
+    On = 1
+}
+
+declare class CalendarRaw {
+    add_event(event: EventType, callback: () => void): void;
+    get(property: PropertyType): any;
+    set(property: PropertyType, value: any): void;
+    execute(method: MethodType, ...args: any[]): any;
+}
+
+interface ICalendar {
+    /**
+     * Zdarzenie wywoływane w momencie wywołania akcji kalendarza
+     * @param callback
+     */
+    addOnCalendar: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane w momencie wznowienia pracy kalendarza
+     * @param callback
+     */
+    addOnStart: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane w momencie zablokowania pracy kalendarza
+     * @param callback
+     */
+    addOnStop: (callback: () => void) => void
+    /**
+     * Zdarzenie wywoływane w momencie anulowania najbliższych akcji
+     * @param callback
+     */
+    addOnCancel: (callback: () => void) => void
+    /** Przełączenie w stan aktywny (State=1) */
+    start: () => void
+    /** Przełączenie w stan zatrzymania (State=0) */
+    stop: () => void
+    /** Anulowanie wywołania wskazanej liczby najbliższych akcji kalendarza */
+    cancelNext: (count?: number) => void
+    /** Reguła kalendarza w formacie CRON lub ERROR w przypadku wprowadzenia błędnej reguły */
+    rule: string
+    /** Czas w minutach od ostatniego spełnienia warunku reguły */
+    readonly sinceLastRun: number
+    /** Czas w minutach do następnego wywołania akcji kalendarza */
+    readonly toNextRun: number
+    /** Stan działania kalendarza: 1 - kalendarz aktywny, 0 - kalendarz nieaktywny */
+    readonly state: StateType
+}
+
+class Calendar implements ICalendar {
+    private onCalendarCallbacks: Array<() => void> = [];
+    private onStartCallbacks: Array<() => void> = [];
+    private onStopCallbacks: Array<() => void> = [];
+    private onCancelCallbacks: Array<() => void> = [];
+
+    constructor(private raw: CalendarRaw) {
+        this.raw.add_event(EventType.OnCalendar, () => {
+            this.onCalendarCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.raw.add_event(EventType.OnStart, () => {
+            this.onStartCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.raw.add_event(EventType.OnStop, () => {
+            this.onStopCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+
+        this.raw.add_event(EventType.OnCancel, () => {
+            this.onCancelCallbacks.forEach(callback => {
+                callback();
+            });
+        });
+    }
+
+    /**
+     * Zdarzenie wywoływane w momencie wywołania akcji kalendarza
+     * @param callback
+     */
+    addOnCalendar(callback: () => void): void {
+        this.onCalendarCallbacks.push(callback);
+    }
+    /**
+     * Zdarzenie wywoływane w momencie wznowienia pracy kalendarza
+     * @param callback
+     */
+    addOnStart(callback: () => void): void {
+        this.onStartCallbacks.push(callback);
+    }
+    /**
+     * Zdarzenie wywoływane w momencie zablokowania pracy kalendarza
+     * @param callback
+     */
+    addOnStop(callback: () => void): void {
+        this.onStopCallbacks.push(callback);
+    }
+    /**
+     * Zdarzenie wywoływane w momencie anulowania najbliższych akcji
+     * @param callback
+     */
+    addOnCancel(callback: () => void): void {
+        this.onCancelCallbacks.push(callback);
+    }
+    /** Przełączenie w stan aktywny (State=1) */
+    start(): void {
+        this.raw.execute(MethodType.Start);
+    }
+    /** Przełączenie w stan zatrzymania (State=0) */
+    stop(): void {
+        this.raw.execute(MethodType.Stop);
+    }
+    /**
+     * Anulowanie wywołania wskazanej liczby najbliższych akcji kalendarza
+     * @param count
+     */
+    cancelNext(count: number = 1): void {
+        this.raw.execute(MethodType.CancelNext, count);
+    }
+    /**
+     * Reguła kalendarza w formacie CRON lub ERROR w przypadku wprowadzenia błędnej reguły
+     * @returns {string}
+     */
+    get rule(): string {
+        return this.raw.get(PropertyType.Rule);
+    }
+    set rule(value: string) {
+        this.raw.set(PropertyType.Rule, value);
+    }
+    /**
+     * Czas w minutach od ostatniego spełnienia warunku reguły
+     * @returns {number}
+     */
+    get sinceLastRun(): number {
+        return this.raw.get(PropertyType.SinceLastRun);
+    }
+    /**
+     * Czas w minutach do następnego wywołania akcji kalendarza
+     * @returns {number}
+     */
+    get toNextRun(): number {
+        return this.raw.get(PropertyType.ToNextRun);
+    }
+    /**
+     * Stan działania kalendarza: 1 - kalendarz aktywny, 0 - kalendarz nieaktywny
+     * @returns {StateType}
+     */
+    get state(): StateType {
+        return this.raw.get(PropertyType.State);
+    }
+}
+
+class CalendarRemote implements ICalendar {
+    constructor(private objectName: string, private gate: RemoteGate) {
+
+    }
+
+    /**
+     * Zdarzenie wywoływane w momencie wywołania akcji kalendarza
+     * @param callback
+     */
+    addOnCalendar(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    /**
+     * Zdarzenie wywoływane w momencie wznowienia pracy kalendarza
+     * @param callback
+     */
+    addOnStart(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    /**
+     * Zdarzenie wywoływane w momencie zablokowania pracy kalendarza
+     * @param callback
+     */
+    addOnStop(_callback: () => void): void {
+        // Remote events are not supported
+    }
+    /**
+     * Zdarzenie wywoływane w momencie anulowania najbliższych akcji
+     * @param callback
+     */
+    addOnCancel(_callback: () => void): void {
+        // Remote events are not supported
+    }
+
+    /** Przełączenie w stan aktywny (State=1) */
+    start(): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.Start)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+
+    /** Przełączenie w stan zatrzymania (State=0) */
+    stop(): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.Stop)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+
+    /**
+     * Anulowanie wywołania wskazanej liczby najbliższych akcji kalendarza
+     * @param count
+     */
+    cancelNext(count: number = 1): void {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .execute()
+            .addParameter(MethodType.CancelNext)
+            .addParameter(count)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+
+    /**
+     * Reguła kalendarza w formacie CRON lub ERROR w przypadku wprowadzenia błędnej reguły
+     * @returns {string}
+     */
+    get rule(): string {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.Rule)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+
+    set rule(value: string) {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .set()
+            .addParameter(PropertyType.Rule)
+            .addParameter(value)
+            .build();
+        this.gate.runScript(cmd!);
+    }
+
+    /**
+     * Czas w minutach od ostatniego spełnienia warunku reguły
+     * @returns {number}
+     */
+    get sinceLastRun(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.SinceLastRun)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+
+    /**
+     * Czas w minutach do następnego wywołania akcji kalendarza
+     * @returns {number}
+     */
+    get toNextRun(): number {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.ToNextRun)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+
+    /**
+     * Stan działania kalendarza: 1 - kalendarz aktywny, 0 - kalendarz nieaktywny
+     * @returns {StateType}
+     */
+    get state(): StateType {
+        const cmd: string | null = rawExecutionBuilderFactory(this.objectName)
+            .get()
+            .addParameter(PropertyType.State)
+            .build();
+        return this.gate.runScript(cmd!);
+    }
+}
+
+export {
+    Calendar, CalendarRaw, CalendarRemote, StateType
+}