@smarthome.exchange/integrations 0.1.0 → 1.0.0

package/dist_ts/integrations/wled/wled.classes.client.js

@@ -1,8 +1,233 @@
-import { SimpleLocalClient } from '../../core/index.js';
-import { wledProfile } from './wled.types.js';
-export class WledClient extends SimpleLocalClient {
-    constructor(configArg) {
-        super(wledProfile, configArg);
+import { DeviceCommunicationError } from '../../core/errors.js';
+import { WledSubscription } from './wled.classes.subscription.js';
+import { validateWledChange, wledPayload } from './wled.commands.js';
+import { WledWriteError } from './wled.errors.js';
+import { isWledRecord, parseWledSnapshot, wledConfig, wledEndpoint } from './wled.validation.js';
+export class WledClient {
+    logger;
+    config;
+    endpoint;
+    lifetime = new AbortController();
+    signal;
+    subscribers = new Set();
+    tail = Promise.resolve();
+    pending = 0;
+    mac;
+    subscription;
+    destroyed = false;
+    healthy = false;
+    constructor(configArg, signalArg, logger) {
+        this.logger = logger;
+        this.config = wledConfig(configArg);
+        this.endpoint = wledEndpoint(this.config);
+        this.mac = this.config.expectedMac;
+        this.signal = AbortSignal.any([this.lifetime.signal, ...(signalArg ? [signalArg] : [])]);
+    }
+    isHealthy() { return !this.destroyed && !this.signal.aborted && this.healthy && (!this.subscription || this.subscription.isHealthy); }
+    getSnapshot(signalArg) {
+        return this.enqueue((signal) => this.readSnapshot(signal), signalArg);
+    }
+    setState(segmentIdArg, changeArg, signalArg) {
+        if (segmentIdArg !== undefined && (!Number.isSafeInteger(segmentIdArg) || segmentIdArg < 0 || segmentIdArg > 254))
+            throw new Error('WLED segment id must be an integer between 0 and 254.');
+        const change = validateWledChange(changeArg);
+        let writeAttempted = false;
+        return this.enqueue(async (signal) => {
+            const before = await this.readSnapshot(signal);
+            const payload = wledPayload(before, segmentIdArg, change);
+            if (signal.aborted)
+                throw new DOMException('WLED operation cancelled.', 'AbortError');
+            writeAttempted = true;
+            const response = await this.requestJson('/json/state', payload, signal);
+            if (!isWledRecord(response) || response.success !== true || response.error !== undefined)
+                throw new DeviceCommunicationError('WLED did not acknowledge the state write.');
+            // Firmware acknowledgement is acceptance; the subsequent read is the authoritative state.
+            return this.readSnapshot(signal);
+        }, signalArg).catch((errorArg) => {
+            if (writeAttempted)
+                throw new WledWriteError(errorArg instanceof Error ? errorArg : new DeviceCommunicationError('WLED write failed.'));
+            throw errorArg;
+        });
+    }
+    async subscribe(handlerArg, signalArg) {
+        this.assertActive(signalArg);
+        const initial = await this.getSnapshot(signalArg);
+        if (initial.info.ws === -1)
+            throw new Error('This WLED build does not support websocket state updates.');
+        let rejectCancellation;
+        const cancellation = new Promise((_, rejectArg) => { rejectCancellation = rejectArg; });
+        const subscriber = {
+            handler: handlerArg,
+            signal: signalArg,
+            abort: () => {
+                rejectCancellation?.(new DOMException('WLED subscription cancelled.', 'AbortError'));
+                void unsubscribe();
+            },
+        };
+        const unsubscribe = async () => {
+            signalArg?.removeEventListener('abort', subscriber.abort);
+            this.subscribers.delete(subscriber);
+            if (this.subscribers.size === 0 && this.subscription) {
+                const subscription = this.subscription;
+                await subscription.stop();
+                if (this.subscription === subscription)
+                    this.subscription = undefined;
+            }
+        };
+        this.subscribers.add(subscriber);
+        signalArg?.addEventListener('abort', subscriber.abort, { once: true });
+        if (signalArg?.aborted)
+            subscriber.abort();
+        try {
+            await Promise.race([this.connectSubscription(), cancellation]);
+            this.assertActive(signalArg);
+            rejectCancellation = undefined;
+            return unsubscribe;
+        }
+        catch (errorArg) {
+            await unsubscribe();
+            throw errorArg;
+        }
+    }
+    async destroy() {
+        this.destroyed = true;
+        this.healthy = false;
+        this.lifetime.abort();
+        for (const subscriber of this.subscribers)
+            subscriber.signal?.removeEventListener('abort', subscriber.abort);
+        this.subscribers.clear();
+        await Promise.all([this.tail, this.subscription?.stop()]);
+        this.subscription = undefined;
+    }
+    async connectSubscription() {
+        if (this.subscription?.isStopping) {
+            const previous = this.subscription;
+            await previous.stop();
+            if (this.subscription === previous)
+                this.subscription = undefined;
+        }
+        this.assertActive();
+        if (this.subscription?.isClosed)
+            this.subscription = undefined;
+        if (!this.subscription) {
+            if (!this.mac)
+                throw new Error('WLED subscription requires a verified device identity.');
+            const url = new URL('/ws', this.endpoint);
+            url.protocol = 'ws:';
+            this.subscription = new WledSubscription({
+                url, mac: this.mac, timeoutMs: this.config.requestTimeoutMs ?? 5000, signal: this.signal,
+                onSnapshot: (snapshotArg) => { this.healthy = true; this.emit({ type: 'snapshot', snapshot: snapshotArg }); },
+                onAvailability: (availableArg) => { this.healthy = availableArg; this.emit({ type: 'availability', available: availableArg }); },
+                onError: (errorArg) => { this.healthy = false; this.emit({ type: 'error', error: errorArg }); },
+            });
+        }
+        await this.subscription.start();
+    }
+    emit(eventArg) {
+        if (this.destroyed || this.signal.aborted)
+            return;
+        for (const subscriber of [...this.subscribers]) {
+            if (!this.subscribers.has(subscriber))
+                continue;
+            try {
+                subscriber.handler(structuredClone(eventArg));
+            }
+            catch {
+                this.logger?.log('error', 'WLED subscriber callback failed.');
+                subscriber.abort();
+            }
+        }
+    }
+    async readSnapshot(signalArg) {
+        const snapshot = parseWledSnapshot(await this.requestJson('/json/si', undefined, signalArg), this.mac);
+        this.assertActive(signalArg);
+        this.mac = snapshot.info.mac;
+        this.healthy = true;
+        return structuredClone(snapshot);
+    }
+    enqueue(operationArg, signalArg) {
+        this.assertActive(signalArg);
+        if (this.pending >= 32)
+            throw new Error('WLED operation queue is full.');
+        this.pending++;
+        const timeout = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; timeout.abort(); }, this.config.requestTimeoutMs ?? 5000);
+        const signal = AbortSignal.any([this.signal, timeout.signal, ...(signalArg ? [signalArg] : [])]);
+        const cancelled = () => timedOut ? new DeviceCommunicationError('WLED operation timed out.') : new DOMException('WLED operation cancelled.', 'AbortError');
+        let rejectCancellation;
+        const cancellation = new Promise((_, rejectArg) => { rejectCancellation = rejectArg; });
+        const handleAbort = () => { this.healthy = false; rejectCancellation?.(cancelled()); };
+        signal.addEventListener('abort', handleAbort, { once: true });
+        if (signal.aborted)
+            handleAbort();
+        const operation = this.tail.then(async () => {
+            if (signal.aborted)
+                throw cancelled();
+            return operationArg(signal);
+        }).catch((errorArg) => {
+            this.healthy = false;
+            if (timedOut)
+                throw new DeviceCommunicationError('WLED operation timed out.');
+            if (signal.aborted)
+                throw new DOMException('WLED operation cancelled.', 'AbortError');
+            if (errorArg instanceof Error)
+                throw errorArg;
+            throw new DeviceCommunicationError('WLED operation failed.');
+        }).finally(() => {
+            this.pending--;
+            clearTimeout(timer);
+            signal.removeEventListener('abort', handleAbort);
+            rejectCancellation = undefined;
+        });
+        this.tail = operation.then(() => undefined, () => undefined);
+        return Promise.race([operation, cancellation]);
+    }
+    async requestJson(pathArg, bodyArg, signalArg) {
+        let response;
+        try {
+            response = await fetch(new URL(pathArg, this.endpoint), { method: bodyArg ? 'POST' : 'GET', headers: { accept: 'application/json', ...(bodyArg ? { 'content-type': 'application/json' } : {}) }, body: bodyArg ? JSON.stringify(bodyArg) : undefined, signal: signalArg, redirect: 'error' });
+        }
+        catch {
+            throw new DeviceCommunicationError('WLED HTTP request failed.');
+        }
+        if (!response.ok || !response.body) {
+            await response.body?.cancel();
+            throw new DeviceCommunicationError(`WLED HTTP request failed with status ${response.status}.`);
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.byteLength;
+                if (size > 1024 * 1024)
+                    throw new DeviceCommunicationError('WLED HTTP response exceeds the size limit.');
+                chunks.push(value);
+            }
+            try {
+                return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            }
+            catch {
+                throw new DeviceCommunicationError('WLED returned invalid HTTP JSON.');
+            }
+        }
+        catch (errorArg) {
+            await reader.cancel();
+            throw errorArg;
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    assertActive(signalArg) {
+        if (this.destroyed)
+            throw new Error('WLED client has been destroyed.');
+        if (this.signal.aborted || signalArg?.aborted)
+            throw new DOMException('WLED operation cancelled.', 'AbortError');
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5jbGFzc2VzLmNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ludGVncmF0aW9ucy93bGVkL3dsZWQuY2xhc3Nlcy5jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTlDLE1BQU0sT0FBTyxVQUFXLFNBQVEsaUJBQThCO0lBQzVELFlBQVksU0FBc0I7UUFDaEMsS0FBSyxDQUFDLFdBQVcsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNoQyxDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wled.classes.client.js","sourceRoot":"","sources":["../../../ts/integrations/wled/wled.classes.client.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/wled/wled.classes.configflow.d.ts

@@ -1,5 +1,5 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { IWledConfig } from './wled.types.js';
-export declare class WledConfigFlow extends SimpleLocalConfigFlow<IWledConfig> {
-    constructor();
+export declare class WledConfigFlow implements IConfigFlow<IWledConfig> {
+    start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IWledConfig>>;
 }

package/dist_ts/integrations/wled/wled.classes.configflow.js

@@ -1,8 +1,35 @@
-import { SimpleLocalConfigFlow } from '../../core/index.js';
-import { wledProfile } from './wled.types.js';
-export class WledConfigFlow extends SimpleLocalConfigFlow {
-    constructor() {
-        super(wledProfile);
+import { WledClient } from './wled.classes.client.js';
+import { wledPlainFields } from './wled.commands.js';
+import { WledCandidateValidator } from './wled.discovery.js';
+import { wledConfig } from './wled.validation.js';
+export class WledConfigFlow {
+    async start(candidateArg, contextArg) {
+        void contextArg;
+        const admitted = await new WledCandidateValidator().validate(candidateArg);
+        const endpoint = admitted.candidate;
+        if (!endpoint)
+            return { kind: 'error', error: 'WLED config flow requires an admitted WLED manual or mDNS endpoint.' };
+        return {
+            kind: 'form', title: 'Connect WLED', description: 'Validate the controller HTTP endpoint and pin its returned MAC identity. WLED has no API authentication or native TLS.',
+            fields: [{ name: 'host', label: 'Host', type: 'text', required: true }, { name: 'port', label: 'Port', type: 'number' }, { name: 'expectedMac', label: 'Expected MAC', type: 'text' }],
+            submit: async (valuesArg) => {
+                if (!wledPlainFields(valuesArg, ['host', 'port', 'expectedMac']))
+                    return { kind: 'error', error: 'WLED config contains unsupported settings.' };
+                let client;
+                try {
+                    const config = wledConfig({ host: valuesArg.host === undefined ? endpoint.host : valuesArg.host, port: valuesArg.port === undefined ? endpoint.port : valuesArg.port, expectedMac: valuesArg.expectedMac === undefined ? endpoint.macAddress : valuesArg.expectedMac });
+                    client = new WledClient(config);
+                    const snapshot = await client.getSnapshot();
+                    return { kind: 'done', title: 'WLED configured', config: { ...config, expectedMac: snapshot.info.mac } };
+                }
+                catch {
+                    return { kind: 'error', error: 'Could not validate the WLED endpoint or MAC identity.' };
+                }
+                finally {
+                    await client?.destroy();
+                }
+            },
+        };
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5jbGFzc2VzLmNvbmZpZ2Zsb3cuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9pbnRlZ3JhdGlvbnMvd2xlZC93bGVkLmNsYXNzZXMuY29uZmlnZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFOUMsTUFBTSxPQUFPLGNBQWUsU0FBUSxxQkFBa0M7SUFDcEU7UUFDRSxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/integrations/wled/wled.classes.integration.d.ts

@@ -1,11 +1,31 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import type { IIntegrationRuntime, IIntegrationSetupContext } from '../../core/types.js';
 import { WledConfigFlow } from './wled.classes.configflow.js';
 import type { IWledConfig } from './wled.types.js';
-export declare class WledIntegration extends SimpleLocalIntegration<IWledConfig> {
+export declare class WledIntegration extends BaseIntegration<IWledConfig> {
     readonly domain = "wled";
-    readonly discoveryDescriptor: import("../../core/classes.discoverydescriptor.js").DiscoveryDescriptor;
+    readonly displayName = "WLED";
+    readonly status: 'control-runtime';
+    readonly discoveryDescriptor: import("../../index.js").DiscoveryDescriptor;
     readonly configFlow: WledConfigFlow;
-    constructor();
+    readonly metadata: {
+        readonly source: 'native-typescript';
+        readonly upstreamDomain: "wled";
+        readonly integrationType: 'device';
+        readonly iotClass: 'local_push';
+        readonly configFlow: true;
+        readonly runtime: {
+            readonly type: 'control-runtime';
+            readonly platforms: readonly ['light'];
+            readonly services: readonly ['turn_on', 'turn_off', 'set_level', 'set_color'];
+            readonly controls: true;
+        };
+    };
+    private readonly runtimes;
+    private readonly pendingClients;
+    private destroyed;
+    setup(configArg: IWledConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime>;
+    destroy(): Promise<void>;
 }
 export declare class HomeAssistantWledIntegration extends WledIntegration {
 }

package/dist_ts/integrations/wled/wled.classes.integration.js

@@ -1,15 +1,179 @@
-import { SimpleLocalIntegration } from '../../core/index.js';
+import * as plugins from '../../plugins.js';
+import { BaseIntegration } from '../../core/classes.baseintegration.js';
+import { WledClient } from './wled.classes.client.js';
 import { WledConfigFlow } from './wled.classes.configflow.js';
+import { wledPlainFields, validateWledChange } from './wled.commands.js';
 import { createWledDiscoveryDescriptor } from './wled.discovery.js';
-import { wledDomain, wledProfile } from './wled.types.js';
-export class WledIntegration extends SimpleLocalIntegration {
-    domain = wledDomain;
+import { WledMapper } from './wled.mapper.js';
+import { wledProfile } from './wled.types.js';
+import { WledWriteError } from './wled.errors.js';
+export class WledIntegration extends BaseIntegration {
+    domain = 'wled';
+    displayName = 'WLED';
+    status = 'control-runtime';
     discoveryDescriptor = createWledDiscoveryDescriptor();
     configFlow = new WledConfigFlow();
-    constructor() {
-        super(wledProfile);
+    metadata = wledProfile.metadata;
+    runtimes = new Set();
+    pendingClients = new Set();
+    destroyed = false;
+    async setup(configArg, contextArg) {
+        if (this.destroyed)
+            throw new Error('WLED integration has been destroyed.');
+        const client = new WledClient(configArg, contextArg.abortSignal, contextArg.logger);
+        this.pendingClients.add(client);
+        try {
+            const snapshot = await client.getSnapshot();
+            if (this.destroyed)
+                throw new Error('WLED integration has been destroyed.');
+            const runtime = new WledRuntime(client, snapshot, () => this.runtimes.delete(runtime));
+            this.runtimes.add(runtime);
+            this.pendingClients.delete(client);
+            return runtime;
+        }
+        catch (errorArg) {
+            await client.destroy();
+            this.pendingClients.delete(client);
+            throw errorArg;
+        }
+    }
+    async destroy() {
+        this.destroyed = true;
+        await Promise.all([...this.runtimes].map((runtimeArg) => runtimeArg.destroy()).concat([...this.pendingClients].map(async (clientArg) => {
+            await clientArg.destroy();
+            this.pendingClients.delete(clientArg);
+        })));
     }
 }
 export class HomeAssistantWledIntegration extends WledIntegration {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2xlZC5jbGFzc2VzLmludGVncmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvaW50ZWdyYXRpb25zL3dsZWQvd2xlZC5jbGFzc2VzLmludGVncmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzdELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVwRSxPQUFPLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTFELE1BQU0sT0FBTyxlQUFnQixTQUFRLHNCQUFtQztJQUN0RCxNQUFNLEdBQUcsVUFBVSxDQUFDO0lBQ3BCLG1CQUFtQixHQUFHLDZCQUE2QixFQUFFLENBQUM7SUFDdEQsVUFBVSxHQUFHLElBQUksY0FBYyxFQUFFLENBQUM7SUFFbEQ7UUFDRSxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDRCQUE2QixTQUFRLGVBQWU7Q0FBRyJ9
+class WledRuntime {
+    client;
+    snapshot;
+    onDestroyed;
+    domain = 'wled';
+    constructor(client, snapshot, onDestroyed) {
+        this.client = client;
+        this.snapshot = snapshot;
+        this.onDestroyed = onDestroyed;
+    }
+    isHealthy() { return this.client.isHealthy(); }
+    async devices(signalArg) {
+        this.snapshot = await this.client.getSnapshot(signalArg);
+        return WledMapper.toDevices(this.snapshot, this.isHealthy());
+    }
+    async entities() {
+        this.snapshot = await this.client.getSnapshot();
+        return WledMapper.toEntities(this.snapshot, this.isHealthy());
+    }
+    async subscribe(handlerArg, signalArg) {
+        let previous = WledMapper.toEntities(this.snapshot);
+        return this.client.subscribe((eventArg) => {
+            const emit = (event) => handlerArg({
+                ...event, integrationDomain: this.domain, deviceId: WledMapper.deviceId(this.snapshot), timestamp: Date.now(),
+            });
+            if (eventArg.type === 'snapshot') {
+                this.snapshot = eventArg.snapshot;
+                const current = WledMapper.toEntities(this.snapshot, true);
+                for (const entity of current) {
+                    const old = previous.find((entryArg) => entryArg.id === entity.id);
+                    if (JSON.stringify(old) !== JSON.stringify(entity))
+                        emit({ type: old ? 'state_changed' : 'entity_added', entityId: entity.id, data: { entity } });
+                }
+                for (const entity of previous)
+                    if (!current.some((entryArg) => entryArg.id === entity.id))
+                        emit({ type: 'entity_removed', entityId: entity.id });
+                previous = current;
+            }
+            else if (eventArg.type === 'availability')
+                emit({ type: 'availability_changed', data: { available: eventArg.available } });
+            else
+                emit({ type: 'error', data: { message: eventArg.error.message } });
+        }, signalArg);
+    }
+    async callService(requestArg) {
+        try {
+            if (!wledPlainFields(requestArg, ['domain', 'service', 'target', 'data']) || !wledPlainFields(requestArg.target, ['deviceId', 'entityId']))
+                throw new Error('WLED requires a plain service request and exact target.');
+            if (requestArg.domain !== 'light' || !['turn_on', 'turn_off', 'set_level', 'set_color'].includes(requestArg.service))
+                throw new Error('WLED supports light.turn_on, turn_off, set_level and set_color.');
+            const segmentId = this.targetSegment(requestArg.target);
+            const fields = requestArg.service === 'turn_off' ? [] : requestArg.service === 'set_level' ? ['brightness'] : requestArg.service === 'set_color' ? ['rgb_color', 'white'] : ['brightness', 'rgb_color', 'white'];
+            const data = requestArg.data ?? {};
+            if (!wledPlainFields(data, fields) || Object.values(data).some((valueArg) => valueArg === undefined))
+                throw new Error('WLED service contains unsupported or undefined data.');
+            if (requestArg.service === 'set_level' && data.brightness === undefined || requestArg.service === 'set_color' && data.rgb_color === undefined && data.white === undefined)
+                throw new Error('WLED service requires an explicit value.');
+            const change = validateWledChange({
+                on: requestArg.service === 'turn_on' ? true : requestArg.service === 'turn_off' ? false : undefined,
+                brightness: data.brightness, rgb: data.rgb_color, white: data.white,
+            });
+            this.snapshot = await this.client.setState(segmentId, change);
+            return { success: true, data: structuredClone(this.snapshot) };
+        }
+        catch (errorArg) {
+            return this.failure(errorArg);
+        }
+    }
+    async writeFeature(requestArg, signalArg) {
+        try {
+            if (!wledPlainFields(requestArg, ['device', 'feature', 'value'], ['device', 'feature', 'value']) ||
+                !wledPlainFields(requestArg.device, ['id', 'integrationDomain', 'name', 'room', 'protocol', 'manufacturer', 'model', 'online', 'features', 'state', 'metadata'], ['id', 'integrationDomain']) ||
+                !wledPlainFields(requestArg.feature, ['id', 'capability', 'name', 'readable', 'writable', 'unit'], ['id']))
+                throw new Error('WLED feature writes require a plain request, device, feature and own value without accessors.');
+            if (requestArg.device.id !== WledMapper.deviceId(this.snapshot) || requestArg.device.integrationDomain !== this.domain)
+                throw new Error('WLED feature target does not belong to this controller.');
+            const device = WledMapper.toDevices(this.snapshot)[0];
+            const feature = device.features.find((entryArg) => entryArg.id === requestArg.feature.id);
+            if (!feature?.writable)
+                throw new Error('WLED feature is not a writable capability of this controller.');
+            const segment = /^segment_(\d+)_(power|brightness|rgb|white)$/.exec(feature.id);
+            const key = segment?.[2] ?? feature.id;
+            const change = {};
+            if (key === 'power') {
+                if (typeof requestArg.value !== 'boolean')
+                    throw new Error('WLED power requires a boolean.');
+                change.on = requestArg.value;
+            }
+            else if (key === 'brightness' || key === 'white') {
+                if (typeof requestArg.value !== 'number')
+                    throw new Error('WLED brightness and white require integer values.');
+                change[key] = requestArg.value;
+            }
+            else if (key === 'rgb') {
+                if (typeof requestArg.value !== 'string' || !/^#[a-f\d]{6}$/i.test(requestArg.value))
+                    throw new Error('WLED RGB feature requires #rrggbb.');
+                const value = requestArg.value;
+                change.rgb = [Number.parseInt(value.slice(1, 3), 16), Number.parseInt(value.slice(3, 5), 16), Number.parseInt(value.slice(5, 7), 16)];
+            }
+            else
+                throw new Error('WLED feature is not supported.');
+            this.snapshot = await this.client.setState(segment ? Number(segment[1]) : undefined, change, signalArg);
+            return { success: true, data: structuredClone(this.snapshot) };
+        }
+        catch (errorArg) {
+            return this.failure(errorArg);
+        }
+    }
+    async destroy() { await this.client.destroy(); this.onDestroyed(); }
+    targetSegment(targetArg) {
+        const deviceId = WledMapper.deviceId(this.snapshot);
+        if (targetArg.deviceId !== undefined && targetArg.deviceId !== deviceId)
+            throw new Error('WLED device target does not belong to this controller.');
+        if (targetArg.entityId === undefined) {
+            if (targetArg.deviceId !== deviceId)
+                throw new Error('WLED requires an exact controller or segment target.');
+            return undefined;
+        }
+        if (targetArg.entityId === WledMapper.entityId(this.snapshot))
+            return undefined;
+        const segment = this.snapshot.state.seg.find((entryArg) => WledMapper.entityId(this.snapshot, entryArg.id) === targetArg.entityId);
+        if (!segment)
+            throw new Error('WLED entity target does not belong to an active segment of this controller.');
+        return segment.id;
+    }
+    failure(errorArg) {
+        return { success: false, error: errorArg instanceof Error ? errorArg.message : 'WLED operation failed.', data: { effectOutcome: errorArg instanceof WledWriteError ? errorArg.effectOutcome : 'not-sent' } };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wled.classes.integration.js","sourceRoot":"","sources":["../../../ts/integrations/wled/wled.classes.integration.ts"],"names":[],"mappings":"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"}

package/dist_ts/integrations/wled/wled.classes.subscription.d.ts

@@ -0,0 +1,37 @@
+import type { IWledSnapshot } from './wled.types.js';
+interface IWledSubscriptionOptions {
+    url: URL;
+    mac: string;
+    timeoutMs: number;
+    signal: AbortSignal;
+    onSnapshot(snapshotArg: IWledSnapshot): void;
+    onAvailability(availableArg: boolean): void;
+    onError(errorArg: Error): void;
+}
+export declare class WledSubscription {
+    private readonly options;
+    private socket?;
+    private starting?;
+    private resolveStart?;
+    private rejectStart?;
+    private closing?;
+    private resolveClose?;
+    private deadline?;
+    private stopping;
+    private closed;
+    private healthy;
+    constructor(options: IWledSubscriptionOptions);
+    get isHealthy(): boolean;
+    get isClosed(): boolean;
+    get isStopping(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private readonly handleMessage;
+    private readonly handleError;
+    private readonly handleClose;
+    private readonly handleAbort;
+    private fail;
+    private setHealthy;
+    private finishClose;
+}
+export {};